@Override
    public String read(Decoder decoder) throws Exception {
        return decoder.readNullableString();
    }

    @Override
    public void write(Encoder encoder, String value) throws Exception {
        encoder.writeNullableString(value);
    }

        @Override
        public void write(Encoder encoder, CacheEntry<PGPPublicKeyRing> value) throws Exception {
            encoder.writeLong(value.timestamp);
            PGPPublicKeyRing key = value.value;
            if (key != null) {
                encoder.writeBoolean(true);
                encoder.writeBinary(key.getEncoded());
            } else {
                encoder.writeBoolean(false);
            }
        }

import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class YesNoQuestionPromptEventSerializer implements Serializer<YesNoQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, YesNoQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
    }

    @Override

    }

    public <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()
        def encoder = new KryoBackedEncoder(bytes)
        serializer.write(encoder, value)
        encoder.flush()

        return bytes.toByteArray()
    }

        @Override
        public void write(Encoder encoder, DaemonStopEvent value) throws Exception {
            encoder.writeLong(value.timestamp.getTime());
            encoder.writeLong(value.pid);
            encoder.writeBoolean(value.status != null);
            if (value.status != null) {
                encoder.writeByte((byte) value.status.ordinal());
            }

            encoder.writeNullableString(value.reason);
        }

        } to codecs

    private
    fun writeContextFor(
        encoder: Encoder,
        tracer: Tracer?,
        codecs: Codecs
    ) = writeContextFor(
        encoder,
        tracer,
        codecs.userTypesCodec()
    )

    private
    fun writeContextFor(
        encoder: Encoder,
        tracer: Tracer?,
        codec: Codec<Any?>
    ) = DefaultWriteContext(

import org.gradle.internal.serialize.Decoder
import org.gradle.internal.serialize.Encoder
import org.gradle.internal.serialize.graph.readFile
import org.gradle.internal.serialize.graph.writeCollection
import org.gradle.internal.serialize.graph.writeFile


internal
fun Encoder.writeClassPath(classPath: ClassPath) {
    // Ensure that the proper type is going to be restored,

        def serializer = Mock(Serializer)
        def decoder = Mock(Decoder)
        def encoder = Mock(Encoder)

        given:
        def stateful = Serializers.stateful(serializer)
        def reader = stateful.newReader(decoder)
        def writer = stateful.newWriter(encoder)

        when:
        def result1 = reader.read()
        def result2 = reader.read()

        then:

            analysisSerializer.write(encoder, value.outputSnapshot);
            annotationProcessingDataSerializer.write(encoder, value.annotationProcessingData);
            analysisSerializer.write(encoder, value.classpathSnapshot);
            compilerApiDataSerializer.write(encoder, value.compilerApiData);
        }
    }

    /**
     * Reads the contents of the given block.
     * The current thread performs the decoding.
     */
    T read(BlockAddress blockAddress);

    interface Writer<T> {
        void write(Encoder encoder, T value) throws Exception;
    }

    interface Reader<T> {
        T read(Decoder decoder) throws Exception;
    }