this.fileAccess = fileAccess;
        this.serializer = serializer;
        this.chmod = chmod;
    }

    @Override
    public T get() {
        return fileAccess.readFile((Supplier<T>) this::deserialize);
    }

    @Override
    public void set(final T newValue) {
        fileAccess.writeFile(() -> serialize(newValue));
    }

    @Override
    public T update(final UpdateAction<T> updateAction) {

     * reason) will be replaced by a {@link PlaceholderException}.
     *
     * @param inputSteam stream to read the object from
     * @param classLoader loader used to load exception classes
     * @return the de-serialized object
     */

        synchronized (lock) {
            return cache.load(() -> {
                try {
                    return binaryData.read(decoder -> deserialize(decoder, graphResults, artifactResults, buildOperationProcessor));
                } finally {
                    try {
                        binaryData.close();
                    } catch (IOException e) {

#include "tensorflow/core/tpu/kernels/tpu_compile_op_support.h"
#include "tsl/platform/statusor.h"

namespace tensorflow {
namespace tf2xla {
namespace internal {

// Compiles a serialized MLIR module and returns a serialized MLIR module of the
// result of running all the MLIR Bridge passes. If compile_to_xla_hlo is true
// then those passes include all the Legalization to XLA HLO which is returned
// in the compilation_result.

   *
   * <ul>
   *   <li>If {@code C} explicitly implements {@link Object#equals}, the deserialized instance will
   *       be checked to be equal to the instance before serialization.
   *   <li>If {@code C} doesn't explicitly implement {@code equals} but instead inherits it from a
   *       superclass, no equality check is done on the deserialized instance because it's not clear

        }

        ClientProvidedPhasedAction clientProvidedPhasedAction = (ClientProvidedPhasedAction) action;
        InternalPhasedAction phasedAction = (InternalPhasedAction) payloadSerializer.deserialize(clientProvidedPhasedAction.getPhasedAction());

        return runClientAction(new ClientActionImpl(phasedAction, action), buildController);
    }

    private class ClientActionImpl implements ClientAction {

@KaAnalysisNonPublicApi
public typealias KtKlibSourceFileNameProvider = KaKlibSourceFileNameProvider

@KaAnalysisNonPublicApi
public interface KaKlibSourceFileProviderMixIn : KaSessionMixIn {
    /**
     * If [KtDeclaration] is a deserialized, klib based symbol, then information about the original
     * [SourceFile] might be retained.
     */
    public fun KaDeclarationSymbol.getKlibSourceFileName(): String? =

std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizeWeightPass(
    const ::stablehlo::quantization::QuantizationComponentSpec&
        quantization_component_spec = {});

// Converts a serialized StableHLO module to bfloat16 and output serialized
// module.
absl::StatusOr<std::string> ConvertSerializedStableHloModuleToBfloat16(
    StringRef serialized_stablehlo_module);

std::unique_ptr<OperationPass<ModuleOp>>

import spock.lang.Specification

import static org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode

class WorkerConfigSerializerTest extends Specification {

    def "serialized and de-serialized WorkerConfig is equivalent to original"() {

        given:
        WorkerConfig original = new WorkerConfig(
            LogLevel.ERROR,
            true,
            "/path/to/user/home",

/**
 * The main entry point for a worker process that is using the system ClassLoader strategy. Reads worker configuration and a serialized worker action from stdin,
 * sets up the worker ClassLoader, and then delegates to {@link org.gradle.process.internal.worker.child.SystemApplicationClassLoaderWorker} to deserialize and execute the action.
 */
public class GradleWorkerMain {
    public void run() throws Exception {