@Override
    public HashCode read(Decoder decoder) throws IOException {
        byte hashSize = decoder.readByte();
        byte[] hash = new byte[hashSize];
        decoder.readBytes(hash);
        return HashCode.fromBytes(hash);
    }

    @Override
    public void write(Encoder encoder, HashCode value) throws IOException {
        byte[] hash = value.toByteArray();
        encoder.writeByte((byte) hash.length);

            Map<String, DependentsSet> constantDependents = constantDependentsSerializer.read(decoder);
            return CompilerApiData.withConstantsMapping(sourceToClassMapping, new ConstantToDependentsMapping(constantDependents));
        }

        @Override
        public void write(Encoder encoder, CompilerApiData value) throws Exception {
            encoder.writeBoolean(value.isAvailable());
            if (value.isAvailable()) {

    }

    static class InefficientSerializer implements Serializer<Long> {
        @Override
        void write(Encoder encoder, Long value) throws Exception {
            value.times { int n ->
                encoder.writeInt(n)
            }
        }

        @Override
        Long read(Decoder decoder) throws EOFException, Exception {
            throw new UnsupportedOperationException()
        }
    }

            Decoder decoder = new InputStreamBackedDecoder(inputStream);
            String pidString = decoder.readNullableString();
            String uid = decoder.readString();
            Long pid = pidString == null ? null : Long.parseLong(pidString);
            Address address = new MultiChoiceAddressSerializer().read(decoder);
            File daemonLog = new File(decoder.readString());

import org.gradle.internal.serialize.Decoder;
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());

        @Override
        public DaemonStopEvent read(Decoder decoder) throws EOFException, Exception {
            long timestamp = decoder.readLong();
            long pid = decoder.readLong();
            DaemonExpirationStatus status = decoder.readBoolean() ? DaemonExpirationStatus.values()[decoder.readByte()] : null;
            String reason = decoder.readNullableString();

    @Override
    public GeneratedResource read(Decoder decoder) throws Exception {
        return new GeneratedResource(LOCATION_SERIALIZER.read(decoder), stringSerializer.read(decoder));
    }

    @Override
    public void write(Encoder encoder, GeneratedResource value) throws Exception {
        LOCATION_SERIALIZER.write(encoder, value.getLocation());
        stringSerializer.write(encoder, value.getPath());
    }

    public ModuleComponentFileArtifactIdentifier read(Decoder decoder) throws Exception {
        ModuleComponentIdentifier componentIdentifier = (ModuleComponentIdentifier) componentIdentifierSerializer.read(decoder);
        String fileName = decoder.readString();
        return new ModuleComponentFileArtifactIdentifier(componentIdentifier, fileName);
    }

    @Override

            encoder.writeString(url.toString());
        }
    }

    @Override
    public VisitableURLClassLoader.Spec read(Decoder decoder) throws Exception {
        byte typeTag = decoder.readByte();
        String name = decoder.readString();
        List<URL> classpath = new ArrayList<>();
        int classpathSize = decoder.readInt();
        for (int i=0; i<classpathSize; i++) {

    def "adapts Serializer to StatefulSerializer"() {
        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()