} else {
            encoder.writeBoolean(true);
            encoder.writeSmallLong(event.getBuildOperationId().getId());
        }
    }

    @Override
    public LogEvent read(Decoder decoder) throws Exception {
        long timestamp = decoder.readLong();
        String category = decoder.readString();
        LogLevel logLevel = logLevelSerializer.read(decoder);

            encoder.writeString(entry.getKey());
            fileSystemSnapshotSerializer.write(encoder, entry.getValue());
        }
    }

    private ValueSnapshot readValueSnapshot(Decoder decoder) throws Exception {
        return valueSnapshotSerializer.read(decoder);
    }

    private void writeValueSnapshot(Encoder encoder, ValueSnapshot snapshot) throws Exception {

    private void writeComponentData(ComponentGraphResolveState component, Encoder encoder) throws Exception {
        encoder.writeBoolean(true);
        componentIdSerializer.write(encoder, component.getId());
        moduleVersionIdSerializer.write(encoder, component.getMetadata().getModuleVersionId());
    }

    @Override
    public void readComponentDetails(Decoder decoder, ResolvedComponentVisitor visitor) throws Exception {

        encoder.writeSmallLong(value.getSelector().getResultId());
        encoder.writeBoolean(value.isConstraint());
        encoder.writeSmallLong(value.getFromVariant());
        if (value.getFailure() == null) {
            if (value.getSelectedVariant() != null) {
                encoder.writeByte(SUCCESSFUL);
                encoder.writeSmallLong(value.getSelected());
                encoder.writeSmallLong(value.getSelectedVariant());

    @Override
    public PublishArtifactLocalArtifactMetadata read(Decoder decoder) throws Exception {
        ComponentIdentifier identifier = componentIdentifierSerializer.read(decoder);
        String artifactName = decoder.readString();
        String artifactExtension = decoder.readString();
        String artifactType = decoder.readString();
        String artifactClassifier = decoder.readNullableString();

	// Give callers the opportunity to wrap encoders and decoders.  For decoders, each returned decoder will
	// be passed to the recognizer so that multiple decoders are available.
	var encoder runtime.Encoder = s
	if opts.EncoderDecoratorFn != nil {
		encoder = opts.EncoderDecoratorFn(encoder)
	}
	decoders := []runtime.Decoder{
		// selected decoder as the primary
		s,
		// universal deserializer as a fallback

        binaryStore.write(encoder -> {
            encoder.writeByte(NODE);
            encoder.writeSmallLong(id);
            moduleVersionIdSerializer.write(encoder, moduleVersionId);
            encoder.writeString(variantName);
        });
    }

    public void done(final Long id) {
        binaryStore.write(encoder -> {
            encoder.writeByte(ROOT);
            encoder.writeSmallLong(id);

    }

    @Override
    public String read(Decoder decoder) throws Exception {
        String name = readName(decoder);
        return interner.intern(name);
    }

    @Override
    public void write(Encoder encoder, String name) throws Exception {
        writeName(name, encoder);
    }

    private String readName(Decoder decoder) throws IOException {
        int id = decoder.readSmallInt();

            encoder.writeString(rejectedVersion);
        }
        encoder.writeNullableString(cst.getBranch());
    }

    private ImmutableAttributes readAttributes(Decoder decoder) throws IOException {
        return attributeContainerSerializer.read(decoder);
    }

    private void writeAttributes(Encoder encoder, ImmutableAttributes attributes) throws IOException {
        attributeContainerSerializer.write(encoder, attributes);

        def decoder = Mock(Decoder)
        def fileName = "file.txt"

        when:
        def result = serializer.read(decoder)

        then:
        1 * decoder.readBoolean() >> true
        1 * decoder.readString() >> fileName
        1 * decoder.readLong() >> 42L
        1 * decoder.readBoolean() >> false