e.Int(position.Column)
}

type encoder struct {
	b           []byte
	stringTable []byte
	strings     map[string]int
}

func (e *encoder) Pos() int {
	return len(e.b)
}

func (e *encoder) Bytes(b []byte) {
	e.b = append(e.b, b...)
}

func (e *encoder) String(s string) {
	if n, ok := e.strings[s]; ok {
		e.Int(n)
		return
	}
	pos := len(e.stringTable)
	e.strings[s] = pos

        }

        encoder.writeSmallInt(flags);

        encoder.writeSmallLong(event.getProgressOperationId().getId());
        if (parentProgressOperationId != null) {
            encoder.writeSmallLong(parentProgressOperationId.getId());
        }
        encoder.writeLong(event.getTimestamp());
        if ((flags & CATEGORY_NAME) != 0) {
            encoder.writeString(event.getCategory());
        }

        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);

    }

    public static void writeLongs(Encoder encoder, long[] array) throws IOException {
        for (long e : array) {
            encoder.writeLong(e);
        }
    }

    public static void writeLengthPrefixedFloats(Encoder encoder, float[] array) throws IOException {
        encoder.writeInt(array.length);
        writeFloats(encoder, array);
    }

    }

    @Override
    public void write(Encoder encoder, ComponentMetadata md) throws Exception {
        moduleVersionIdentifierSerializer.write(encoder, md.getId());
        attributeContainerSerializer.write(encoder, md.getAttributes());
        checkChangingFlag(md);
        writeStatusScheme(encoder, md);
    }

    private void checkChangingFlag(ComponentMetadata md) {

        }
    }

    @Override
    public void write(Encoder encoder, Map<String, FileSystemLocationFingerprint> value) throws Exception {
        encoder.writeSmallInt(value.size());
        for (String key : value.keySet()) {
            encoder.writeString(key);
            FileSystemLocationFingerprint fingerprint = value.get(key);
            writeFingerprint(encoder, fingerprint);
        }
    }

    @Override

    }

    @Override
    public void write(Encoder encoder, AttributeContainer container) throws IOException {
        encoder.writeSmallInt(container.keySet().size());
        for (Attribute<?> attribute : container.keySet()) {
            encoder.writeString(attribute.getName());
            if (attribute.getType().equals(Boolean.class)) {
                encoder.writeByte(BOOLEAN_ATTRIBUTE);

    @Override
    public void write(Encoder encoder, HierarchicalClassLoaderStructure classLoaderStructure) throws Exception {
        if (classLoaderStructure.getParent() == null) {
            encoder.writeByte(ROOT);
        } else {
            encoder.writeByte(HAS_PARENT);
            write(encoder, classLoaderStructure.getParent());
        }

            executionTime
        );
    }

    @Override
    public void write(Encoder encoder, OriginMetadata originMetadata) throws IOException {
        encoder.writeString(originMetadata.getBuildInvocationId());
        hashCodeSerializer.write(encoder, originMetadata.getBuildCacheKey());
        encoder.writeSmallLong(originMetadata.getExecutionTime().toMillis());
    }

    }

    @Override
    public void write(Encoder encoder, PublishArtifactLocalArtifactMetadata value) throws Exception {
        componentIdentifierSerializer.write(encoder, value.getComponentIdentifier());
        PublishArtifact publishArtifact = value.getPublishArtifact();
        encoder.writeString(publishArtifact.getName());
        encoder.writeString(publishArtifact.getType());
        encoder.writeString(publishArtifact.getExtension());