try {
            if (encoder != null) {
                encoder.done();
                encoder.flush();
            }
            return new SimpleBinaryData(file, offset);
        } finally {
            offset = -1;
        }
    }

    @Override
    public void close() {
        try {
            if (encoder != null) {
                encoder.close();
            }
        } finally {

            ClassSetAnalysisData outputSnapshot = analysisSerializer.read(decoder);
            AnnotationProcessingData annotationProcessingData = annotationProcessingDataSerializer.read(decoder);
            ClassSetAnalysisData classpathSnapshot = analysisSerializer.read(decoder);
            CompilerApiData compilerApiData = compilerApiDataSerializer.read(decoder);

    @Override
    public OriginMetadata read(Decoder decoder) throws IOException {
        String buildInvocationId = decoder.readString();
        HashCode buildCacheKey = hashCodeSerializer.read(decoder);
        Duration executionTime = Duration.ofMillis(decoder.readSmallLong());
        return new OriginMetadata(
            buildInvocationId,
            buildCacheKey,

        @Override
        public ObjectReader<T> newReader(final Decoder decoder) {
            return new ObjectReader<T>() {
                @Override
                public T read() throws Exception {
                    return serializer.read(decoder);
                }
            };
        }

        @Override
        public ObjectWriter<T> newWriter(final Encoder encoder) {
            return new ObjectWriter<T>() {

    @Override
    public void write(Encoder encoder, DefaultModuleComponentArtifactIdentifier value) throws Exception {
        componentIdentifierSerializer.write(encoder, value.getComponentIdentifier());
        IvyArtifactNameSerializer.INSTANCE.write(encoder, value.getName());
    }

    @Override
    public DefaultModuleComponentArtifactIdentifier read(Decoder decoder) throws Exception {

        @Override
        public Object[] read(Decoder decoder) throws Exception {
            Object[] result = new Object[serializers.length];
            for (int i = 0; i < serializers.length; i++) {
                result[i] = serializers[i].read(decoder);
            }
            return result;
        }

        @Override
        public void write(Encoder encoder, Object[] value) throws Exception {

    @Override
    public AnnotationProcessorDeclaration read(Decoder decoder) throws EOFException, Exception {
        String name = decoder.readString();
        IncrementalAnnotationProcessorType type = IncrementalAnnotationProcessorType.values()[decoder.readSmallInt()];
        return new AnnotationProcessorDeclaration(name, type);
    }

    @Override
    public void write(Encoder encoder, AnnotationProcessorDeclaration value) throws Exception {

        @Override
        public Object[] read(Decoder decoder) {
            return ZERO_ARGS;
        }

        @Override
        public void write(Encoder encoder, Object[] value) {
        }
    }

    private class ArraySerializer implements Serializer<Object[]> {
        @Override
        public Object[] read(Decoder decoder) throws Exception {

        }
    }

    private
    fun write(encoder: Encoder, value: BuildTreeModelSideEffect) {
        val (context, codecs) = cacheIO.writerContextFor(encoder)
        context.push(IsolateOwners.OwnerHost(host), codecs.userTypesCodec())
        context.runWriteOperation {
            write(value)
        }
    }

    private
    fun read(decoder: Decoder): BuildTreeModelSideEffect {

            default:
                throw new IllegalArgumentException("Unexpected build identifier type.");
        }
    }

    @Override
    public void write(Encoder encoder, BuildIdentifier value) throws IOException {
        if (value == DefaultBuildIdentifier.ROOT) {
            encoder.writeByte(ROOT);
        } else if (value instanceof ForeignBuildIdentifier) {
            encoder.writeByte(FOREIGN);