}

    private
    suspend fun ReadContext.readConfiguration(componentId: ComponentIdentifier, factory: CalculatedValueContainerFactory): LocalConfigurationGraphResolveMetadata {
        val configurationName = readString()
        val configurationAttributes = readNonNull<ImmutableAttributes>()
        val dependencies = readDependencies()
        val variants = readVariants(factory).toSet()

                else -> throw IllegalStateException("$clazz instances is not expected to be stored")
            }
        }

        val removals = readList {
            val key = readString()
            ConfigurationCacheEnvironmentChangeTracker.SystemPropertyRemove(key)
        }

        return ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState(cleared, updates, removals)
    }

        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(
                "deserialize",

	if !isIdent(c) {
		r.syntaxError()
		return
	}
	for isIdent(r.peekByte(false)) {
		r.peek = 0
	}
}

// readString reads a quoted string literal from the input.
// If an identifier is not present, readString records a syntax error.
func (r *importReader) readString() {
	switch r.nextByte(true) {
	case '`':
		for r.err == nil {
			if r.nextByte(false) == '`' {
				break
			}
			if r.eof {

    }
}


fun Decoder.readStrings(): List<String> =
    readCollectionInto({ size -> ArrayList(size) }) {
        readString()
    }


fun Decoder.readStringsSet(): Set<String> =
    readCollectionInto({ size -> LinkedHashSet(size) }) {
        readString()
    }


inline fun <T> Encoder.writeCollection(collection: Collection<T>, writeElement: (T) -> Unit) {

        withGradleIsolate(rootBuild.gradle, userTypesCodec) {
            val identityPath = Path.path(readString())
            val hasProjects = readBoolean()
            if (hasProjects) {
                val rootProjectName = readString()
                val projects: List<ProjectWithNoWork> = readList().uncheckedCast()
                BuildWithNoWork(identityPath, rootProjectName, projects)

            val duplicatesStrategy = readEnum<DuplicatesStrategy>()
            val includeEmptyDirs = readBoolean()
            val isCaseSensitive = readBoolean()
            val filteringCharset = readString()
            val dirMode = readNullableSmallInt()
            val fileMode = readNullableSmallInt()
            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()

    }

    override fun readObjectOverride(): Any? = readContext.runReadOperation {
        read()
    }

    override fun readInt(): Int = readContext.readInt()

    override fun readUTF(): String = readContext.readString()

    override fun read(b: ByteArray): Int = inputStream.read(b)

    override fun markSupported(): Boolean = inputStream.markSupported()

    override fun mark(readlimit: Int) = inputStream.mark(readlimit)

                intermediateModels[modelKey] = address
            }
            val metadata = mutableMapOf<Path, BlockAddress>()
            readCollection {
                val path = Path.path(readString())
                val address = addressSerializer.read(this)
                metadata[path] = address
            }
            val sideEffects = readList {
                addressSerializer.read(this)

private
fun WriteContext.writeAttribute(attribute: Attribute<*>) {
    writeString(attribute.name)
    writeClass(attribute.type)
}


private
fun ReadContext.readAttribute(): Attribute<Any> {
    val name = readString()
    val type = readClass()
    return Attribute.of(name, type.uncheckedCast())
}


private
suspend fun WriteContext.writeManaged(value: Managed) {
    writeSmallInt(value.factoryId)