suspend fun <T : MutableCollection<Any?>> ReadContext.readCollectionInto(factory: (Int) -> T): T =
    readCollectionInto(factory) { read() }


suspend fun WriteContext.writeMap(value: Map<*, *>) {
    writeSmallInt(value.size)
    writeMapEntries(value)
}


suspend fun WriteContext.writeMapEntries(value: Map<*, *>) {
    for (entry in value.entries) {
        write(entry.key)
        write(entry.value)
    }

            if (mapping != null) {
                // Save a reference to the dependency that was written before
                encoder.writeSmallInt(mapping);
            } else {
                encoder.writeSmallInt(nextMapping);
                componentSelectorSerializer.write(encoder, mavenDependency.getSelector());
                writeNullableArtifact(mavenDependency.getDependencyArtifact());

        }

        private void writeStringKeys(Encoder encoder, List<String> keys) throws Exception {
            if (keys == null) {
                encoder.writeSmallInt(0);
            } else {
                encoder.writeSmallInt(keys.size());
                for (String key : keys) {
                    stringSerializer.write(encoder, key);
                }
            }
        }

            encoder.writeSmallInt(outputPropertyHashes.keySet().size());
            for (Map.Entry<String, Collection<HashCode>> entry : outputPropertyHashes.asMap().entrySet()) {
                encoder.writeString(entry.getKey());
                Collection<HashCode> hashes = entry.getValue();
                encoder.writeSmallInt(hashes.size());
                for (HashCode hash : hashes) {

    }

    @Override
    public void write(Encoder encoder, ComponentSelectionReason value) throws IOException {
        List<ComponentSelectionDescriptor> descriptions = value.getDescriptions();
        encoder.writeSmallInt(descriptions.size());
        for (ComponentSelectionDescriptor description : descriptions) {
            componentSelectionDescriptorSerializer.write(encoder, description);
        }
    }

            encoder.writeSmallLong(child);
            encoder.writeSmallInt(artifactId);
        });
    }

    public void nodeArtifacts(final Long node, final int artifactId) {
        binaryStore.write(encoder -> {
            encoder.writeByte(NODE_ARTIFACTS);
            encoder.writeSmallLong(node);
            encoder.writeSmallInt(artifactId);
        });
    }

    @Override
    public void write(Encoder encoder, SerializedPayload value) throws Exception {
        javaSerializer.write(encoder, value.getHeader());
        encoder.writeSmallInt(value.getSerializedModel().size());
        for (byte[] bytes : value.getSerializedModel()) {
            encoder.writeBinary(bytes);
        }
    }

    @Override

            if (idx == null) {
                // new value
                encoder.writeSmallInt(writeIndex.size());
                writeIndex.put(container, writeIndex.size());
                delegate.write(encoder, container);
            } else {
                // known value, only write index
                encoder.writeSmallInt(idx);
            }
        }
    }

        encoder.writeLong(canonicalAddress.getMostSignificantBits());
        encoder.writeLong(canonicalAddress.getLeastSignificantBits());
        encoder.writeInt(address.getPort());
        encoder.writeSmallInt(address.getCandidates().size());
        for (InetAddress inetAddress : address.getCandidates()) {
            encoder.writeBinary(inetAddress.getAddress());
        }
    }

    }

    private
    val encodings = HashMap<Class<*>, TaggedEncoding>()

    override suspend fun WriteContext.encode(value: Any?) = when (value) {
        null -> writeSmallInt(NULL_VALUE)
        else -> taggedEncodingFor(value.javaClass).run {
            writeSmallInt(tag)
            withDebugFrame({
                // TODO:configuration-cache evaluate whether we need to unpack the type here