*  </p>
 *  <p>
 *      Object serialization is a graph-walking process, and as such, it has a recursive nature.
 *  </p>
 *  <p></p>
 *      In order to serialize one object, {@link  org.gradle.internal.serialize.graph.WriteContext#write(java.lang.Object, kotlin.coroutines.Continuation) WriteContext.write(object)} must be invoked.
 *  </p>

object NonPrimitiveArrayCodec : Codec<Array<*>> {
    override suspend fun WriteContext.encode(value: Array<*>) {
        writeArray(value) { element ->
            write(element)
        }
    }

    override suspend fun ReadContext.decode(): Array<*> =
        readArray {
            read()
        }
}


object ShortArrayCodec : Codec<ShortArray> {

}


sealed interface DocumentCheckFailureReason {
    object PluginManagementBlockOrderViolated : DocumentCheckFailureReason
    object PluginsBlockOrderViolated : DocumentCheckFailureReason
    object DuplicatePluginsBlock : DocumentCheckFailureReason
    object DuplicatePluginManagementBlock : DocumentCheckFailureReason

            resourceConnectorFactories
                .single { "https" in it.supportedProtocols }
                .createResourceConnector(object : ResourceConnectorSpecification {})
    }

    private
    object ExecutionAccessCheckerProvider : ServiceRegistrationProvider {
        @Provides
        fun createExecutionAccessChecker(
            listenerManager: ListenerManager,

            String getJava(List<String> cmd) {
                return """
                    Object someArgument = new Object() {
                        public String toString() {
                            return "--some-argument";
                        }
                    };
                    List<Object> command = Arrays.<Object>asList(${ShellScript.cmdToVarargLiterals(cmd)}, someArgument);
                    """
            }

        val enumOrdinal = readSmallInt()
        return enumClass.enumConstants[enumOrdinal]
    }
}


private
object EnumEncoding : Encoding {
    override suspend fun WriteContext.encode(value: Any) {
        writeEnumValueOf(value::class.java, value)
    }
}


private
object EnumSubTypeEncoding : Encoding {
    override suspend fun WriteContext.encode(value: Any) {

    )
}

object AdHocPerformanceScenarioLinux : AdHocPerformanceScenario(Os.LINUX)
object AdHocPerformanceScenarioWindows : AdHocPerformanceScenario(Os.WINDOWS)
object AdHocPerformanceScenarioMacOS : AdHocPerformanceScenario(Os.MACOS, Arch.AMD64)

 */
interface ReflectionToObjectConverter {
    fun apply(objectReflection: ObjectReflection, conversionFilter: ConversionFilter = ConversionFilter.none)
    fun interface ConversionFilter {
        fun filterProperties(dataObjectReflection: ObjectReflection.DataObjectReflection): Iterable<DataProperty>

        companion object {

import kotlin.reflect.KClass
import kotlin.reflect.KType
import kotlin.reflect.typeOf
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs
import kotlin.test.assertTrue


object PropertyTest {
    @Test
    fun `read-only property cannot be written`() {
        val result = schema().resolve("x = y")
        val singleError = result.errors.single().errorReason

import org.gradle.internal.declarativedsl.schemaBuilder.isPublicAndRestricted
import kotlin.reflect.KClass
import kotlin.reflect.full.memberFunctions


/**
 * Provides type discovery via functions that return an object or configure an object accepting a lambda as the last parameter
 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *