object ProxyCodec : EncodingProducer, Decoding {
    override fun encodingForType(type: Class<*>): Encoding? =
        ProxyEncoding.takeIf { Proxy.isProxyClass(type) }

    override suspend fun ReadContext.decode(): Any {
        val interfaces = readClassArray()
        val handler = read() as InvocationHandler
        return Proxy.newProxyInstance(interfaces.first().classLoader, interfaces, handler)
    }
}

 */
class BeanSpec(val bean: Any)


object BeanSpecCodec : Codec<BeanSpec> {

    override suspend fun WriteContext.encode(value: BeanSpec) =
        encodeBean(value.bean)

    override suspend fun ReadContext.decode(): BeanSpec =
        BeanSpec(decodeBean())

        writeClass(value.declaringClass)
        writeString(value.name)
        writeClassArray(value.parameterTypes)
    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()
        val parameterTypes = readClassArray()
        return declaringClass.getDeclaredMethod(methodName, *parameterTypes)
    }

var pemEnd = []byte("\n-----END ")
var pemEndOfLine = []byte("-----")
var colon = []byte(":")

// Decode will find the next PEM formatted block (certificate, private key
// etc) in the input. It returns that block and the remainder of the input. If
// no PEM data is found, p is nil and the whole of the input is returned in
// rest.
func Decode(data []byte) (p *Block, rest []byte) {
	// pemStart begins with a newline. However, at the very beginning of

    override suspend fun WriteContext.encode(value: ApiTextResourceAdapter) {
        writeString((value.inputProperties as URI).toASCIIString())
    }

    override suspend fun ReadContext.decode(): ApiTextResourceAdapter =
        textResourceFactory.fromInsecureUri(readString()) as ApiTextResourceAdapter

    private
    val ReadContext.textResourceFactory: TextResourceFactory

    override suspend fun WriteContext.encode(value: TaskInAnotherBuild) {
        value.run {
            writeString(taskPath)
            write(targetBuild)
        }
    }

    override suspend fun ReadContext.decode(): TaskInAnotherBuild {
        val taskPath = readString()
        val targetBuild = readNonNull<BuildIdentifier>()
        return TaskInAnotherBuild.lazy(
            taskPath,
            targetBuild,

    override suspend fun WriteContext.encode(value: T) {
        // Delegate to the other codec
        withCodec(userTypesCodec) {
            write(value)
        }
    }

    override suspend fun ReadContext.decode(): T {
        // Delegate to the other codec
        return withCodec(userTypesCodec) {
            readNonNull()
        }
    }

object ImmutableListCodec : Codec<ImmutableList<Any>> {

    override suspend fun WriteContext.encode(value: ImmutableList<Any>) {
        writeCollection(value)
    }

    override suspend fun ReadContext.decode(): ImmutableList<Any>? {
        val size = readSmallInt()
        val builder = ImmutableList.builderWithExpectedSize<Any>(size)
        for (i in 0 until size) {
            val value = readNonNull<Any>()

) : Codec<OrdinalNode> {
    override suspend fun WriteContext.encode(value: OrdinalNode) {
        writeEnum(value.type)
        writeInt(value.ordinalGroup.ordinal)
    }

    override suspend fun ReadContext.decode(): OrdinalNode {
        val ordinalType = readEnum<OrdinalNode.Type>()
        val ordinal = readInt()
        return ordinalGroups.group(ordinal).locationsNode(ordinalType)
    }

        encodePreservingSharedIdentityOf(value) {
            write(value.targetVariant)
            writeCollection(value.transformedArtifacts)
        }
    }

    override suspend fun ReadContext.decode(): TransformedProjectArtifactSet {
        return decodePreservingSharedIdentity {
            val targetVariant = readNonNull<ComponentVariantIdentifier>()
            val nodes: List<TransformStepNode> = readList().uncheckedCast()