diff --git a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt index 3eddea009..672ae6865 100644 --- a/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt +++ b/harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt @@ -4,9 +4,12 @@ import godot.api.Node import godot.annotation.RegisterClass import godot.annotation.RegisterFunction import godot.annotation.RegisterProperty -import godot.core.MethodCallable +import godot.core.Callable0 +import godot.core.Callable1 +import godot.core.Callable2 +import godot.core.Callable3 import godot.core.VariantArray -import godot.core.toGodotName +import godot.core.callable3 import godot.core.variantArrayOf import godot.global.GD @@ -17,22 +20,28 @@ class CallableMethodBindTest: Node() { @RegisterFunction fun callWithMethodWithAllBinds() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(1, 2, 3).callUnsafe() + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable0 = unboundCallable.bind(1, 2, 3) + boundCallable.call() } @RegisterFunction fun callWithMethodWithTwoBinds() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(2, 3).callUnsafe(0) + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable1 = unboundCallable.bind(5, 6) + boundCallable.call(4) } @RegisterFunction fun callWithMethodWithOneBind() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe(3).callUnsafe(0, 0) + val unboundCallable: Callable3 = callable3(CallableMethodBindTest::readySignalMethodBindTest) + val boundCallable: Callable2 = unboundCallable.bind(9) + boundCallable.call(7, 8) } @RegisterFunction fun callWithMethodWithNoBind() { - MethodCallable(this, CallableMethodBindTest::readySignalMethodBindTest.toGodotName()).bindUnsafe().callUnsafe(0, 0, 0) + callable3(CallableMethodBindTest::readySignalMethodBindTest).call(10, 11, 12) } @RegisterFunction diff --git a/harness/tests/test/unit/test_callable_method_bind.gd b/harness/tests/test/unit/test_callable_method_bind.gd index 9d899b4ff..f3fb54216 100644 --- a/harness/tests/test/unit/test_callable_method_bind.gd +++ b/harness/tests/test/unit/test_callable_method_bind.gd @@ -26,17 +26,17 @@ func test_method_bind_passing_correct_binds_with_one_args_provided() -> void: binds_test_script.call_with_method_with_two_binds() assert_eq( binds_test_script.method_binds[0], - 0, + 4, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 2, + 5, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 3, + 6, "Incorrect bind value passed" ) binds_test_script.free() @@ -46,17 +46,17 @@ func test_method_bind_passing_correct_binds_with_two_args_provided() -> void: binds_test_script.call_with_method_with_one_bind() assert_eq( binds_test_script.method_binds[0], - 0, + 7, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 0, + 8, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 3, + 9, "Incorrect bind value passed" ) binds_test_script.free() @@ -66,17 +66,17 @@ func test_method_bind_passing_correct_binds_with_three_args_provided() -> void: binds_test_script.call_with_method_with_no_bind() assert_eq( binds_test_script.method_binds[0], - 0, + 10, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[1], - 0, + 11, "Incorrect bind value passed" ) assert_eq( binds_test_script.method_binds[2], - 0, + 12, "Incorrect bind value passed" ) binds_test_script.free() diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt index 5cb14e0ec..e89c457ba 100644 --- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt +++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/CallableGenerationService.kt @@ -13,46 +13,119 @@ import com.squareup.kotlinpoet.ParameterSpec import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy import com.squareup.kotlinpoet.TypeSpec import com.squareup.kotlinpoet.TypeVariableName +import com.squareup.kotlinpoet.asClassName import godot.codegen.poet.GenericClassNameInfo import godot.codegen.services.ICallableGenerationService import godot.common.constants.Constraints +import godot.tools.common.constants.GODOT_METHOD_CALLABLE +import godot.tools.common.constants.GODOT_OBJECT import godot.tools.common.constants.GodotFunctions import godot.tools.common.constants.GodotKotlinJvmTypes +import godot.tools.common.constants.STRING_NAME +import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION import godot.tools.common.constants.VARIANT_PARSER_NIL import godot.tools.common.constants.godotCorePackage import godot.tools.common.constants.godotInteropPackage import java.io.File +import kotlin.reflect.KCallable object CallableGenerationService : ICallableGenerationService { - private const val FUNCTION_PARAMETER_NAME = "function" + private const val CALLABLE_NAME = "Callable" private const val LAMBDA_CALLABLE_NAME = "LambdaCallable" private const val LAMBDA_CONTAINER_NAME = "LambdaContainer" + private const val METHOD_CALLABLE_NAME = "MethodCallable" + + private const val FUNCTION_PARAMETER_NAME = "function" private const val CONTAINER_ARGUMENT_NAME = "container" + private const val TARGET_ARGUMENT_NAME = "target" + private const val METHOD_NAME_ARGUMENT_NAME = "methodName" private const val BOUND_ARGS_ARGUMENT_NAME = "boundArgs" private const val CALLABLE_FUNCTION_NAME = "callable" private const val VARIANT_TYPE_RETURN_NAME = "returnConverter" private const val VARIANT_TYPE_ARGUMENT_NAME = "typeConverters" + + private val CALLABLE_CLASS_NAME = ClassName(godotCorePackage, CALLABLE_NAME) private val LAMBDA_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CALLABLE_NAME) private val LAMBDA_CONTAINER_CLASS_NAME = ClassName(godotCorePackage, LAMBDA_CONTAINER_NAME) + private val METHOD_CALLABLE_CLASS_NAME = ClassName(godotCorePackage, METHOD_CALLABLE_NAME) + private val returnTypeParameter = TypeVariableName("R", ANY.copy(nullable = true)) private val variantConverterClassName = ClassName(godotInteropPackage, GodotKotlinJvmTypes.variantConverter) override fun generate(outputDir: File) { - val callableFileSpec = FileSpec.builder(godotCorePackage, "LambdaCallables") - val containerFileSpec = FileSpec.builder(godotCorePackage, "LambdaContainers") + val callableFileSpec = FileSpec.builder(godotCorePackage, CALLABLE_NAME + "s") + val lambdaFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CALLABLE_NAME + "s") + val containerFileSpec = FileSpec.builder(godotCorePackage, LAMBDA_CONTAINER_NAME + "s") + val methodFileSpec = FileSpec.builder(godotCorePackage, METHOD_CALLABLE_NAME + "s") for (argCount in 0..Constraints.MAX_FUNCTION_ARG_COUNT) { + val callableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME$argCount") val lambdaContainerClassName = ClassName(godotCorePackage, "$LAMBDA_CONTAINER_NAME$argCount") val lambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME$argCount") + val methodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME$argCount") + val callableInfo = GenericClassNameInfo(callableClassName, argCount) val containerInfo = GenericClassNameInfo(lambdaContainerClassName, argCount) - val callableInfo = GenericClassNameInfo(lambdaCallableClassName, argCount) + val lambdaInfo = GenericClassNameInfo(lambdaCallableClassName, argCount) + val methodCallableInfo = GenericClassNameInfo(methodCallableClassName, argCount) val genericParameters = containerInfo.genericTypes - val lambdaTypeName = callableInfo.toLambdaTypeName(returnType = returnTypeParameter) + val lambdaTypeName = lambdaInfo.toLambdaTypeName(returnType = returnTypeParameter) + val callableClassBuilder = TypeSpec + .interfaceBuilder(callableClassName) + .addSuperinterface(CALLABLE_CLASS_NAME) + .addTypeVariable(returnTypeParameter) + .addTypeVariables(genericParameters) + .addFunction( + FunSpec + .builder("call") + .addParameters(callableInfo.toParameterSpecList()) + .returns(returnTypeParameter) + .addCode( + CodeBlock.of( + buildString { + append("return·callUnsafe(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(") as R") + } + ) + ) + .build() + ) + .addFunction( + FunSpec.builder("callDeferred") + .addParameters(callableInfo.toParameterSpecList()) + .addCode( + CodeBlock.of( + buildString { + append("return·callDeferredUnsafe(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(")") + } + ) + ) + .build() + ) + .addFunction( + FunSpec.builder("invoke") + .addParameters(lambdaInfo.toParameterSpecList()) + .returns(returnTypeParameter) + .addCode( + CodeBlock.of( + buildString { + append("return·call(") + append(callableInfo.toArgumentsString("pINDEX", "INDEX")) + append(')') + }, + *genericParameters.toTypedArray() + ) + ) + .addModifiers(KModifier.OPERATOR) + .build() + ) val lambdaContainerClassBuilder = TypeSpec .classBuilder(lambdaContainerClassName) @@ -107,10 +180,10 @@ object CallableGenerationService : ICallableGenerationService { CodeBlock.of( buildString { append("return·($FUNCTION_PARAMETER_NAME·as?·%T)?.invoke(") - append(callableInfo.toArgumentsString("args[INDEX]", "INDEX")) + append(lambdaInfo.toArgumentsString("args[INDEX]", "INDEX")) append(")?:·throw·%T()") }, - callableInfo.toErasedLambdaTypeName(returnType = returnTypeParameter), + lambdaInfo.toErasedLambdaTypeName(returnType = returnTypeParameter), ClassName(godotCorePackage, "InvalidJvmLambdaException") ) ) @@ -121,6 +194,7 @@ object CallableGenerationService : ICallableGenerationService { val lambdaCallableClassBuilder = TypeSpec .classBuilder(lambdaCallableClassName) .superclass(LAMBDA_CALLABLE_CLASS_NAME.parameterizedBy(returnTypeParameter)) + .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters)) .addTypeVariable(returnTypeParameter) .addTypeVariables(genericParameters) .primaryConstructor( @@ -147,82 +221,119 @@ object CallableGenerationService : ICallableGenerationService { .addAnnotation(PublishedApi::class) .build() ) - .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME, BOUND_ARGS_ARGUMENT_NAME) - .addFunction( + .addSuperclassConstructorParameter(CONTAINER_ARGUMENT_NAME) + .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME) + + val methodCallableClassBuilder = TypeSpec + .classBuilder(methodCallableClassName) + .superclass(METHOD_CALLABLE_CLASS_NAME) + .addSuperinterface(callableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters)) + .addTypeVariable(returnTypeParameter) + .addTypeVariables(genericParameters) + .primaryConstructor( FunSpec - .builder("call") - .addParameters(callableInfo.toParameterSpecList()) - .returns(returnTypeParameter) - .addCode( - CodeBlock.of( - buildString { - append("return·$CONTAINER_ARGUMENT_NAME.invokeUnsafe(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(')') - } - ) + .constructorBuilder() + .addModifiers(KModifier.INTERNAL) + .addParameter( + ParameterSpec + .builder( + TARGET_ARGUMENT_NAME, + GODOT_OBJECT + ) + .build() ) - .build() - ) - .addFunction( - FunSpec.builder("callDeferred") - .addParameters(callableInfo.toParameterSpecList()) - .addCode( - CodeBlock.of( - buildString { - append("return·callDeferredUnsafe(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(")") - } - ) + .addParameter( + ParameterSpec + .builder( + METHOD_NAME_ARGUMENT_NAME, + STRING_NAME + ) + .build() ) - .build() - ) - .addFunction( - FunSpec.builder("invoke") - .addParameters(callableInfo.toParameterSpecList()) - .returns(returnTypeParameter) - .addCode( - CodeBlock.of( - buildString { - append("return·call(") - append(callableInfo.toArgumentsString("pINDEX", "INDEX")) - append(')') - }, - *genericParameters.toTypedArray() - ) + .addParameter( + ParameterSpec + .builder( + BOUND_ARGS_ARGUMENT_NAME, + ARRAY.parameterizedBy(ANY.copy(nullable = true)) + ) + .defaultValue("emptyArray()") + .build() ) - .addModifiers(KModifier.OPERATOR) + .addAnnotation(PublishedApi::class) .build() ) + .addSuperclassConstructorParameter(TARGET_ARGUMENT_NAME) + .addSuperclassConstructorParameter(METHOD_NAME_ARGUMENT_NAME) + .addSuperclassConstructorParameter(BOUND_ARGS_ARGUMENT_NAME) val typeVariables = genericParameters.toMutableList() var remainingParameters = 0 while (typeVariables.isNotEmpty()) { - val bindClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") - val bindInfo = GenericClassNameInfo(bindClassName, remainingParameters) + val boundCallableClassName = ClassName(godotCorePackage, "$CALLABLE_NAME${remainingParameters}") + val boundLambdaCallableClassName = ClassName(godotCorePackage, "$LAMBDA_CALLABLE_NAME${remainingParameters}") + val boundMethodCallableClassName = ClassName(godotCorePackage, "$METHOD_CALLABLE_NAME${remainingParameters}") + + val bindInfo = GenericClassNameInfo(boundLambdaCallableClassName, remainingParameters) + + callableClassBuilder.addFunction( + FunSpec.builder("bind") + .addModifiers(KModifier.ABSTRACT) + .addParameters( + typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName -> + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } + ) + .returns(boundCallableClassName.parameterizedBy(listOf(returnTypeParameter) + bindInfo.genericTypes)) + .build() + ) lambdaCallableClassBuilder.addFunction( FunSpec.builder("bind") + .addModifiers(KModifier.OVERRIDE) .addParameters( - typeVariables - .mapIndexed { index: Int, typeVariableName: TypeVariableName -> - ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) - .build() + typeVariables.mapIndexed { index: Int, typeVariableName: TypeVariableName -> + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } + ) + .addCode( + buildString { + append("return·%T($CONTAINER_ARGUMENT_NAME, arrayOf(") + + for (index in (0.. + ParameterSpec.builder("p${index + remainingParameters}", typeVariableName) + .build() + } ) .addCode( buildString { - append("return·%T($CONTAINER_ARGUMENT_NAME, arrayOf(") + append("return·%T($TARGET_ARGUMENT_NAME, $METHOD_NAME_ARGUMENT_NAME, arrayOf(") for (index in (0..).name.%M())", + methodCallableClassName.parameterizedBy(listOf(returnTypeParameter) + genericParameters), + KCallable::class.asClassName(), + TO_GODOT_NAME_UTIL_FUNCTION, + ) + ) + .build() + ) } callableFileSpec @@ -313,5 +456,27 @@ object CallableGenerationService : ICallableGenerationService { ) .build() .writeTo(outputDir) + + lambdaFileSpec + .addAnnotation( + AnnotationSpec + .builder(ClassName("kotlin", "Suppress")) + .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"") + .addMember("\"unused\"") + .build() + ) + .build() + .writeTo(outputDir) + + methodFileSpec + .addAnnotation( + AnnotationSpec + .builder(ClassName("kotlin", "Suppress")) + .addMember("\"PackageDirectoryMismatch\", \"UNCHECKED_CAST\"") + .addMember("\"unused\"") + .build() + ) + .build() + .writeTo(outputDir) } } diff --git a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt index f4e0bf9c1..342d5475e 100644 --- a/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt +++ b/kt/api-generator/src/main/kotlin/godot/codegen/services/impl/SignalGenerationService.kt @@ -17,24 +17,31 @@ import godot.codegen.poet.GenericClassNameInfo import godot.codegen.services.ISignalGenerationService import godot.common.constants.Constraints import godot.tools.common.constants.GODOT_OBJECT +import godot.tools.common.constants.STRING_NAME +import godot.tools.common.constants.TO_GODOT_NAME_UTIL_FUNCTION import godot.tools.common.constants.godotCorePackage import godot.tools.common.constants.kotlinReflectPackage import java.io.File object SignalGenerationService : ISignalGenerationService { - + private const val CALLABLE_NAME = "Callable" private const val SIGNAL_CLASS_NAME = "Signal" + private const val INSTANCE_PARAMETER = "instance" private const val NAME_PARAMETER = "name" private const val PROPERTY_PARAMETER = "property" private const val THIS_REF_PARAMETER_NAME = "thisRef" + private const val CONNECT_PARAMETER_NAME = "connect" private const val EMIT_METHOD_NAME = "emit" + private const val CONNECT_METHOD_NAME = "connect" private const val SIGNAL_METHOD_NAME = "signal" + private const val FLAGS_PARAMETER_NAME = "flags" private const val UNSAFE_SUFFIX = "Unsafe" private const val DELEGATE_PROPERTY_NAME = "delegate" + private val connectFlagClassName = ClassName(godotCorePackage, "Object.ConnectFlags") private val propertyClassname = ClassName(kotlinReflectPackage, "KProperty").parameterizedBy(STAR) private val readOnlyPropertyClassName = ClassName("kotlin.properties", "ReadOnlyProperty") @@ -67,7 +74,7 @@ object SignalGenerationService : ISignalGenerationService { } private fun generateSignalClass(argCount: Int, genericClassNameInfo: GenericClassNameInfo): TypeSpec { - + val callableClassName = ClassName(godotCorePackage, CALLABLE_NAME + argCount) return genericClassNameInfo .toTypeSpecBuilder() .superclass(ClassName(godotCorePackage, SIGNAL_CLASS_NAME)) @@ -77,7 +84,7 @@ object SignalGenerationService : ISignalGenerationService { .addParameters( listOf( ParameterSpec.builder(INSTANCE_PARAMETER, GODOT_OBJECT).build(), - ParameterSpec.builder(NAME_PARAMETER, STRING).build() + ParameterSpec.builder(NAME_PARAMETER, STRING_NAME).build() ) ) .addAnnotation(PublishedApi::class) @@ -105,6 +112,25 @@ object SignalGenerationService : ISignalGenerationService { ) ) .build(), + FunSpec.builder(CONNECT_METHOD_NAME) + .returns(UNIT) + .addParameters( + listOf( + ParameterSpec.builder( + CONNECT_PARAMETER_NAME, + callableClassName.parameterizedBy(listOf(STAR) + genericClassNameInfo.genericTypes) + ).build(), + ParameterSpec.builder(FLAGS_PARAMETER_NAME, connectFlagClassName) + .defaultValue("%T.%L", connectFlagClassName, "DEFAULT") + .build() + ) + ) + .addCode( + CodeBlock.of( + "connectUnsafe($CONNECT_PARAMETER_NAME, $FLAGS_PARAMETER_NAME)" + ) + ) + .build(), ) ) .addType(generateSignalCompanion(argCount, genericClassNameInfo)) @@ -139,8 +165,9 @@ object SignalGenerationService : ISignalGenerationService { .returns(genericClassNameInfo.genericClassName) .addCode( CodeBlock.of( - "return·%T(thisRef,·property.name)", + "return·%T(thisRef,·property.%M())", genericClassNameInfo.className, + TO_GODOT_NAME_UTIL_FUNCTION ) ) .build() @@ -157,8 +184,9 @@ object SignalGenerationService : ISignalGenerationService { .addParameter(ParameterSpec.builder("signalName", STRING).build()) .addCode( CodeBlock.of( - "return·%T(this,·signalName)", + "return·%T(this,·signalName.%M())", genericClassNameInfo.genericClassName, + TO_GODOT_NAME_UTIL_FUNCTION ) ) .addAnnotation( diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt new file mode 100644 index 000000000..700bbcae8 --- /dev/null +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Callables.kt @@ -0,0 +1,1740 @@ +@file:Suppress( + "PackageDirectoryMismatch", "UNCHECKED_CAST", + "unused", +) + +package godot.core + +import kotlin.Suppress + +public interface Callable0 : Callable { + public fun call(): R = callUnsafe() as R + + public fun callDeferred() = callDeferredUnsafe() + + public operator fun invoke(): R = call() +} + +public interface Callable1 : Callable { + public fun call(p0: P0): R = callUnsafe(p0) as R + + public fun callDeferred(p0: P0) = callDeferredUnsafe(p0) + + public operator fun invoke(p0: P0): R = call(p0) + + public fun bind(p0: P0): Callable0 +} + +public interface Callable2 : Callable { + public fun call(p0: P0, p1: P1): R = callUnsafe(p0, p1) as R + + public fun callDeferred(p0: P0, p1: P1) = callDeferredUnsafe(p0, p1) + + public operator fun invoke(p0: P0, p1: P1): R = call(p0, p1) + + public fun bind(p0: P0, p1: P1): Callable0 + + public fun bind(p1: P1): Callable1 +} + +public interface Callable3 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + ): R = callUnsafe(p0, p1, p2) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + ) = callDeferredUnsafe(p0, p1, p2) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + ): R = call(p0, p1, p2) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + ): Callable0 + + public fun bind(p1: P1, p2: P2): Callable1 + + public fun bind(p2: P2): Callable2 +} + +public interface Callable4 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): R = callUnsafe(p0, p1, p2, p3) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ) = callDeferredUnsafe(p0, p1, p2, p3) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): R = call(p0, p1, p2, p3) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + ): Callable1 + + public fun bind(p2: P2, p3: P3): Callable2 + + public fun bind(p3: P3): Callable3 +} + +public interface Callable5 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): R = callUnsafe(p0, p1, p2, p3, p4) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): R = call(p0, p1, p2, p3, p4) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + ): Callable2 + + public fun bind(p3: P3, p4: P4): Callable3 + + public fun bind(p4: P4): Callable4 +} + +public interface Callable6 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): R = call(p0, p1, p2, p3, p4, p5) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + ): Callable3 + + public fun bind(p4: P4, p5: P5): Callable4 + + public fun bind(p5: P5): Callable5 +} + +public interface Callable7 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): R = call(p0, p1, p2, p3, p4, p5, p6) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + ): Callable4 + + public fun bind(p5: P5, p6: P6): Callable5 + + public fun bind(p6: P6): Callable6 +} + +public interface Callable8 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + ): Callable5 + + public fun bind(p6: P6, p7: P7): Callable6 + + public fun bind(p7: P7): Callable7 +} + +public interface Callable9 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + ): Callable6 + + public fun bind(p7: P7, p8: P8): Callable7 + + public fun bind(p8: P8): Callable8 +} + +public interface Callable10 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + ): Callable7 + + public fun bind(p8: P8, p9: P9): Callable8 + + public fun bind(p9: P9): Callable9 +} + +public interface Callable11 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + ): Callable8 + + public fun bind(p9: P9, p10: P10): Callable9 + + public fun bind(p10: P10): Callable10 +} + +public interface Callable12 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + ): Callable9 + + public fun bind(p10: P10, p11: P11): Callable10 + + public fun bind(p11: P11): Callable11 +} + +public interface Callable13 : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + ): Callable10 + + public fun bind(p11: P11, p12: P12): Callable11 + + public fun bind(p12: P12): Callable12 +} + +public interface Callable14 : + Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + ): Callable11 + + public fun bind(p12: P12, p13: P13): + Callable12 + + public fun bind(p13: P13): Callable13 +} + +public interface Callable15 : + Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ): Callable11 + + public fun bind( + p12: P12, + p13: P13, + p14: P14, + ): Callable12 + + public fun bind(p13: P13, p14: P14): + Callable13 + + public fun bind(p14: P14): + Callable14 +} + +public interface Callable16 + : Callable { + public fun call( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): R = callUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) as R + + public fun callDeferred( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) + + public operator fun invoke( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) + + public fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable0 + + public fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable1 + + public fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable2 + + public fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable3 + + public fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable4 + + public fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable5 + + public fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable6 + + public fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable7 + + public fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable8 + + public fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable9 + + public fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable10 + + public fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable11 + + public fun bind( + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ): Callable12 + + public fun bind( + p13: P13, + p14: P14, + p15: P15, + ): Callable13 + + public fun bind(p14: P14, p15: P15): + Callable14 + + public fun bind(p15: P15): + Callable15 +} diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt index a510be006..fe1d8de2a 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/LambdaCallables.kt @@ -14,13 +14,7 @@ import kotlin.Suppress public class LambdaCallable0 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(): R = container.invokeUnsafe() - - public fun callDeferred() = callDeferredUnsafe() - - public operator fun invoke(): R = call() -} +) : LambdaCallable(container, boundArgs), Callable0 public inline fun callable0(noinline function: () -> R) = LambdaCallable0(LambdaContainer0(variantMapper.getOrDefault(R::class, NIL), arrayOf(), function)) @@ -30,84 +24,58 @@ public inline fun (() -> R).asCallable() = callable0(this) public class LambdaCallable1 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(p0: P0): R = container.invokeUnsafe(p0) - - public fun callDeferred(p0: P0) = callDeferredUnsafe(p0) - - public operator fun invoke(p0: P0): R = call(p0) - - public fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0)) +) : LambdaCallable(container, boundArgs), Callable1 { + public override fun bind(p0: P0) = LambdaCallable0(container, arrayOf(p0, *boundArgs)) } -public inline fun callable1(noinline function: (p0: P0) -> R) = +public inline fun callable1(noinline function: (p0: P0) -> R) = LambdaCallable1(LambdaContainer1(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!), function)) -public inline fun ((p0: P0) -> R).asCallable() = callable1(this) +public inline fun ((p0: P0) -> R).asCallable() = callable1(this) public class LambdaCallable2 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call(p0: P0, p1: P1): R = container.invokeUnsafe(p0, p1) - - public fun callDeferred(p0: P0, p1: P1) = callDeferredUnsafe(p0, p1) - - public operator fun invoke(p0: P0, p1: P1): R = call(p0, p1) +) : LambdaCallable(container, boundArgs), Callable2 { + public override fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1, + *boundArgs)) - public fun bind(p0: P0, p1: P1) = LambdaCallable0(container, arrayOf(p0, p1)) - - public fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1)) + public override fun bind(p1: P1) = LambdaCallable1(container, arrayOf(p1, + *boundArgs)) } -public inline fun callable2(noinline function: (p0: P0, +public inline fun callable2(noinline function: (p0: P0, p1: P1) -> R) = LambdaCallable2(LambdaContainer2(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!), function)) -public inline fun ((p0: P0, p1: P1) -> R).asCallable() = +public inline fun ((p0: P0, p1: P1) -> R).asCallable() = callable2(this) public class LambdaCallable3 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( +) : LambdaCallable(container, boundArgs), Callable3 { + public override fun bind( p0: P0, p1: P1, p2: P2, - ): R = container.invokeUnsafe(p0, p1, p2) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, *boundArgs)) - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - ) = callDeferredUnsafe(p0, p1, p2) + public override fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2, + *boundArgs)) - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - ): R = call(p0, p1, p2) - - public fun bind( - p0: P0, - p1: P1, - p2: P2, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2)) - - public fun bind(p1: P1, p2: P2) = LambdaCallable1(container, arrayOf(p1, p2)) - - public fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2)) + public override fun bind(p2: P2) = LambdaCallable2(container, arrayOf(p2, + *boundArgs)) } -public inline fun callable3(noinline function: ( +public inline fun callable3(noinline function: ( p0: P0, p1: P1, p2: P2, ) -> R) = LambdaCallable3(LambdaContainer3(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -116,47 +84,28 @@ public inline fun (( public class LambdaCallable4 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ): R = container.invokeUnsafe(p0, p1, p2, p3) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ) = callDeferredUnsafe(p0, p1, p2, p3) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - ): R = call(p0, p1, p2, p3) - - public fun bind( +) : LambdaCallable(container, boundArgs), Callable4 { + public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, *boundArgs)) - public fun bind(p2: P2, p3: P3) = LambdaCallable2(container, arrayOf(p2, p3)) + public override fun bind(p2: P2, p3: P3) = LambdaCallable2(container, + arrayOf(p2, p3, *boundArgs)) - public fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3)) + public override fun bind(p3: P3) = LambdaCallable3(container, arrayOf(p3, + *boundArgs)) } -public inline fun callable4(noinline +public inline fun callable4(noinline function: ( p0: P0, p1: P1, @@ -165,7 +114,7 @@ public inline fun ca ) -> R) = LambdaCallable4(LambdaContainer4(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -175,58 +124,36 @@ public inline fun (( public class LambdaCallable5 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( +) : LambdaCallable(container, boundArgs), Callable5 { + public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, *boundArgs)) - public fun callDeferred( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, p4: P4, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, *boundArgs)) - public operator fun invoke( - p0: P0, - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, - ): R = call(p0, p1, p2, p3, p4) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, *boundArgs)) - public fun bind( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4)) + public override fun bind(p3: P3, p4: P4) = LambdaCallable3(container, + arrayOf(p3, p4, *boundArgs)) - public fun bind( - p1: P1, - p2: P2, - p3: P3, - p4: P4, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4)) - - public fun bind( - p2: P2, - p3: P3, - p4: P4, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4)) - - public fun bind(p3: P3, p4: P4) = LambdaCallable3(container, arrayOf(p3, p4)) - - public fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4)) + public override fun bind(p4: P4) = LambdaCallable4(container, arrayOf(p4, + *boundArgs)) } -public inline fun +public inline fun callable5(noinline function: ( p0: P0, p1: P1, @@ -236,7 +163,7 @@ public inline fun R) = LambdaCallable5(LambdaContainer5(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -247,71 +174,46 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5) - - public fun callDeferred( +) : LambdaCallable(container, boundArgs), Callable6 { + public override fun bind( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, *boundArgs)) - public operator fun invoke( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, - ): R = call(p0, p1, p2, p3, p4, p5) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, *boundArgs)) - public fun bind( - p0: P0, - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, p5: P5, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, *boundArgs)) - public fun bind( - p1: P1, - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, *boundArgs)) - public fun bind( - p2: P2, - p3: P3, - p4: P4, - p5: P5, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5)) + public override fun bind(p4: P4, p5: P5) = LambdaCallable4(container, + arrayOf(p4, p5, *boundArgs)) - public fun bind( - p3: P3, - p4: P4, - p5: P5, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5)) - - public fun bind(p4: P4, p5: P5) = LambdaCallable4(container, arrayOf(p4, p5)) - - public fun bind(p5: P5) = LambdaCallable5(container, arrayOf(p5)) + public override fun bind(p5: P5) = LambdaCallable5(container, + arrayOf(p5, *boundArgs)) } -public inline fun callable6(noinline function: ( +public inline fun callable6(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -321,8 +223,8 @@ public inline fun R) = LambdaCallable6(LambdaContainer6(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -334,28 +236,8 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6) - - public operator fun invoke( +) : LambdaCallable(container, boundArgs), Callable7 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -363,56 +245,47 @@ public class LambdaCallable7 @PublishedApi intern p4: P4, p5: P5, p6: P6, - ): R = call(p0, p1, p2, p3, p4, p5, p6) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, *boundArgs)) - public fun bind( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, *boundArgs)) - public fun bind( - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, *boundArgs)) - public fun bind( - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, p6: P6, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, *boundArgs)) - public fun bind( - p3: P3, + public override fun bind( p4: P4, p5: P5, p6: P6, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, *boundArgs)) - public fun bind( - p4: P4, - p5: P5, - p6: P6, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6)) - - public fun bind(p5: P5, p6: P6) = LambdaCallable5(container, - arrayOf(p5, p6)) + public override fun bind(p5: P5, p6: P6) = LambdaCallable5(container, + arrayOf(p5, p6, *boundArgs)) - public fun bind(p6: P6) = LambdaCallable6(container, arrayOf(p6)) + public override fun bind(p6: P6) = LambdaCallable6(container, + arrayOf(p6, *boundArgs)) } -public inline fun callable7(noinline function: ( +public inline fun callable7(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -423,8 +296,8 @@ public inline fun R) = LambdaCallable7(LambdaContainer7(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -437,30 +310,8 @@ public inline fun @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) - - public operator fun invoke( +) : LambdaCallable(container, boundArgs), Callable8 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -469,10 +320,9 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, *boundArgs)) - public fun bind( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -480,56 +330,47 @@ public class LambdaCallable8 @PublishedApi in p5: P5, p6: P6, p7: P7, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, *boundArgs)) - public fun bind( - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, *boundArgs)) - public fun bind( - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, *boundArgs)) - public fun bind( - p3: P3, + public override fun bind( p4: P4, p5: P5, p6: P6, p7: P7, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, *boundArgs)) - public fun bind( - p4: P4, + public override fun bind( p5: P5, p6: P6, p7: P7, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, *boundArgs)) - public fun bind( - p5: P5, - p6: P6, - p7: P7, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7)) - - public fun bind(p6: P6, p7: P7) = LambdaCallable6(container, - arrayOf(p6, p7)) + public override fun bind(p6: P6, p7: P7) = LambdaCallable6(container, + arrayOf(p6, p7, *boundArgs)) - public fun bind(p7: P7) = LambdaCallable7(container, arrayOf(p7)) + public override fun bind(p7: P7) = LambdaCallable7(container, + arrayOf(p7, *boundArgs)) } -public inline fun callable8(noinline function: ( +public inline fun callable8(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -541,8 +382,8 @@ public inline fun R) = LambdaCallable8(LambdaContainer8(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -557,32 +398,8 @@ public class LambdaCallable9 @PublishedAp constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) - - public operator fun invoke( +) : LambdaCallable(container, boundArgs), Callable9 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -592,10 +409,9 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs)) - public fun bind( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -604,10 +420,9 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, *boundArgs)) - public fun bind( - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -615,57 +430,47 @@ public class LambdaCallable9 @PublishedAp p6: P6, p7: P7, p8: P8, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, *boundArgs)) - public fun bind( - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, *boundArgs)) - public fun bind( - p3: P3, + public override fun bind( p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, *boundArgs)) - public fun bind( - p4: P4, + public override fun bind( p5: P5, p6: P6, p7: P7, p8: P8, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, *boundArgs)) - public fun bind( - p5: P5, + public override fun bind( p6: P6, p7: P7, p8: P8, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, *boundArgs)) - public fun bind( - p6: P6, - p7: P7, - p8: P8, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8)) + public override fun bind(p7: P7, p8: P8) = + LambdaCallable7(container, arrayOf(p7, p8, *boundArgs)) - public fun bind(p7: P7, p8: P8) = LambdaCallable7(container, - arrayOf(p7, p8)) - - public fun bind(p8: P8) = LambdaCallable8(container, - arrayOf(p8)) + public override fun bind(p8: P8) = LambdaCallable8(container, + arrayOf(p8, *boundArgs)) } -public inline fun callable9(noinline function: ( +public inline fun callable9(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -678,8 +483,8 @@ public inline fun R) = LambdaCallable9(LambdaContainer9(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -695,47 +500,8 @@ public class LambdaCallable10 @Publis constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) - - public fun bind( +) : LambdaCallable(container, boundArgs), Callable10 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -746,9 +512,10 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -758,9 +525,10 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -769,9 +537,10 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -779,47 +548,54 @@ public class LambdaCallable10 @Publis p7: P7, p8: P8, p9: P9, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, p9: P9, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, + *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, + *boundArgs)) - public fun bind(p8: P8, p9: P9) = LambdaCallable8(container, - arrayOf(p8, p9)) + public override fun bind(p8: P8, p9: P9) = + LambdaCallable8(container, arrayOf(p8, p9, + *boundArgs)) - public fun bind(p9: P9) = LambdaCallable9(container, - arrayOf(p9)) + public override fun bind(p9: P9) = + LambdaCallable9(container, arrayOf(p9, + *boundArgs)) } -public inline fun callable10(noinline function: ( +public inline fun callable10(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -833,8 +609,8 @@ public inline fun R) = LambdaCallable10(LambdaContainer10(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -851,36 +627,9 @@ public class LambdaCallable11 @P constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) - - public operator fun invoke( +) : LambdaCallable(container, boundArgs), + Callable11 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -892,10 +641,10 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -906,10 +655,10 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable0(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -919,10 +668,10 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -931,10 +680,10 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p3: P3, + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -942,57 +691,54 @@ public class LambdaCallable11 @P p8: P8, p9: P9, p10: P10, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p4: P4, + public override fun bind( p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, - ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10)) - - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10, + *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, p10: P10, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, + *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, - ) = LambdaCallable8(container, arrayOf(p8, p9, p10)) + ) = LambdaCallable8(container, arrayOf(p8, p9, p10, + *boundArgs)) - public fun bind(p9: P9, p10: P10) = - LambdaCallable9(container, arrayOf(p9, p10)) + public override fun bind(p9: P9, p10: P10) = + LambdaCallable9(container, arrayOf(p9, p10, + *boundArgs)) - public fun bind(p10: P10) = LambdaCallable10(container, - arrayOf(p10)) + public override fun bind(p10: P10) = + LambdaCallable10(container, arrayOf(p10, + *boundArgs)) } -public inline fun callable11(noinline function: ( +public inline fun callable11(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1007,8 +753,8 @@ public inline fun R) = LambdaCallable11(LambdaContainer11(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1026,8 +772,9 @@ public class LambdaCallable12, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( +) : LambdaCallable(container, boundArgs), + Callable12 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1040,10 +787,10 @@ public class LambdaCallable12(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun callDeferred( - p0: P0, + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1055,11 +802,10 @@ public class LambdaCallable12(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public operator fun invoke( - p0: P0, - p1: P1, + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1070,12 +816,10 @@ public class LambdaCallable12(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( - p0: P0, - p1: P1, - p2: P2, + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1085,48 +829,10 @@ public class LambdaCallable12(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ) = LambdaCallable1(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) - - public fun bind( - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ) = LambdaCallable2(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)) - - public fun bind( - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - ) = LambdaCallable3(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11)) - - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1135,9 +841,10 @@ public class LambdaCallable12(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable4(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1145,48 +852,55 @@ public class LambdaCallable12(container, arrayOf(p5, p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable5(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, - ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10, p11)) + ) = LambdaCallable6(container, arrayOf(p6, p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, p11)) + ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, p11, + *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, p11: P11, - ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11)) + ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11, + *boundArgs)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, - ) = LambdaCallable9(container, arrayOf(p9, p10, p11)) + ) = LambdaCallable9(container, arrayOf(p9, p10, p11, + *boundArgs)) - public fun bind(p10: P10, p11: P11) = - LambdaCallable10(container, arrayOf(p10, p11)) + public override fun bind(p10: P10, p11: P11) = + LambdaCallable10(container, arrayOf(p10, p11, + *boundArgs)) - public fun bind(p11: P11) = - LambdaCallable11(container, arrayOf(p11)) + public override fun bind(p11: P11) = + LambdaCallable11(container, arrayOf(p11, + *boundArgs)) } -public inline fun callable12(noinline - function: ( +public inline fun + callable12(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1202,8 +916,8 @@ public inline fun R) = LambdaCallable12(LambdaContainer12(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1222,40 +936,9 @@ public class LambdaCallable13, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) - - public operator fun invoke( +) : LambdaCallable(container, boundArgs), + Callable13 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1269,25 +952,10 @@ public class LambdaCallable13(container, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable0(container, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1300,9 +968,10 @@ public class LambdaCallable13(container, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable1(container, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1314,9 +983,10 @@ public class LambdaCallable13(container, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable2(container, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1327,9 +997,10 @@ public class LambdaCallable13(container, arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable3(container, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1339,9 +1010,10 @@ public class LambdaCallable13(container, arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable4(container, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1350,9 +1022,10 @@ public class LambdaCallable13(container, arrayOf(p5, p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable5(container, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1360,47 +1033,54 @@ public class LambdaCallable13(container, arrayOf(p6, p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable6(container, + arrayOf(p6, p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, - ) = LambdaCallable7(container, arrayOf(p7, p8, p9, p10, p11, p12)) + ) = LambdaCallable7(container, + arrayOf(p7, p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, - ) = LambdaCallable8(container, arrayOf(p8, p9, p10, p11, p12)) + ) = LambdaCallable8(container, + arrayOf(p8, p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, p12: P12, - ) = LambdaCallable9(container, arrayOf(p9, p10, p11, p12)) + ) = LambdaCallable9(container, + arrayOf(p9, p10, p11, p12, *boundArgs)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, - ) = LambdaCallable10(container, arrayOf(p10, p11, p12)) + ) = LambdaCallable10(container, + arrayOf(p10, p11, p12, *boundArgs)) - public fun bind(p11: P11, p12: P12) = - LambdaCallable11(container, arrayOf(p11, p12)) + public override fun bind(p11: P11, p12: P12) = + LambdaCallable11(container, + arrayOf(p11, p12, *boundArgs)) - public fun bind(p12: P12) = - LambdaCallable12(container, arrayOf(p12)) + public override fun bind(p12: P12) = + LambdaCallable12(container, + arrayOf(p12, *boundArgs)) } -public inline fun +public inline fun callable13(noinline function: ( p0: P0, p1: P1, @@ -1418,8 +1098,8 @@ public inline fun R) = LambdaCallable13(LambdaContainer13(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1439,59 +1119,9 @@ public class LambdaCallable14, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) - - public fun bind( +) : LambdaCallable(container, boundArgs), + Callable14 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1507,9 +1137,9 @@ public class LambdaCallable14(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1524,9 +1154,9 @@ public class LambdaCallable14(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1540,9 +1170,9 @@ public class LambdaCallable14(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1555,9 +1185,9 @@ public class LambdaCallable14(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1569,9 +1199,9 @@ public class LambdaCallable14(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1582,9 +1212,9 @@ public class LambdaCallable14(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1594,9 +1224,9 @@ public class LambdaCallable14(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1605,9 +1235,9 @@ public class LambdaCallable14(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -1615,44 +1245,44 @@ public class LambdaCallable14(container, - arrayOf(p8, p9, p10, p11, p12, p13)) + arrayOf(p8, p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, ) = LambdaCallable9(container, - arrayOf(p9, p10, p11, p12, p13)) + arrayOf(p9, p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, p13: P13, ) = LambdaCallable10(container, - arrayOf(p10, p11, p12, p13)) + arrayOf(p10, p11, p12, p13, *boundArgs)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, ) = LambdaCallable11(container, - arrayOf(p11, p12, p13)) + arrayOf(p11, p12, p13, *boundArgs)) - public fun bind(p12: P12, p13: P13) = + public override fun bind(p12: P12, p13: P13) = LambdaCallable12(container, - arrayOf(p12, p13)) + arrayOf(p12, p13, *boundArgs)) - public fun bind(p13: P13) = + public override fun bind(p13: P13) = LambdaCallable13(container, - arrayOf(p13)) + arrayOf(p13, *boundArgs)) } -public inline fun callable14(noinline function: ( +public inline fun callable14(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1670,9 +1300,9 @@ public inline fun R) = LambdaCallable14(LambdaContainer14(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1693,62 +1323,9 @@ public class LambdaCallable15, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ): R = container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) - - public fun bind( +) : LambdaCallable(container, boundArgs), + Callable15 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -1765,9 +1342,9 @@ public class LambdaCallable15(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -1783,9 +1360,9 @@ public class LambdaCallable15(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -1800,9 +1377,9 @@ public class LambdaCallable15(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -1816,9 +1393,9 @@ public class LambdaCallable15(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -1831,9 +1408,9 @@ public class LambdaCallable15(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -1845,9 +1422,9 @@ public class LambdaCallable15(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -1858,9 +1435,9 @@ public class LambdaCallable15(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -1870,9 +1447,9 @@ public class LambdaCallable15(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -1881,9 +1458,9 @@ public class LambdaCallable15(container, - arrayOf(p8, p9, p10, p11, p12, p13, p14)) + arrayOf(p8, p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, @@ -1891,44 +1468,44 @@ public class LambdaCallable15(container, - arrayOf(p9, p10, p11, p12, p13, p14)) + arrayOf(p9, p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, ) = LambdaCallable10(container, - arrayOf(p10, p11, p12, p13, p14)) + arrayOf(p10, p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, p14: P14, ) = LambdaCallable11(container, - arrayOf(p11, p12, p13, p14)) + arrayOf(p11, p12, p13, p14, *boundArgs)) - public fun bind( + public override fun bind( p12: P12, p13: P13, p14: P14, ) = LambdaCallable12(container, - arrayOf(p12, p13, p14)) + arrayOf(p12, p13, p14, *boundArgs)) - public fun bind(p13: P13, p14: P14) = + public override fun bind(p13: P13, p14: P14) = LambdaCallable13(container, - arrayOf(p13, p14)) + arrayOf(p13, p14, *boundArgs)) - public fun bind(p14: P14) = + public override fun bind(p14: P14) = LambdaCallable14(container, - arrayOf(p14)) + arrayOf(p14, *boundArgs)) } -public inline fun callable15(noinline function: ( +public inline fun callable15(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -1947,9 +1524,9 @@ public inline fun R) = LambdaCallable15(LambdaContainer15(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, @@ -1971,66 +1548,9 @@ public class LambdaCallable16 @PublishedApi internal constructor( container: LambdaContainer, boundArgs: Array = emptyArray(), -) : LambdaCallable(container) { - public fun call( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ): R = - container.invokeUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public fun callDeferred( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ) = callDeferredUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public operator fun invoke( - p0: P0, - p1: P1, - p2: P2, - p3: P3, - p4: P4, - p5: P5, - p6: P6, - p7: P7, - p8: P8, - p9: P9, - p10: P10, - p11: P11, - p12: P12, - p13: P13, - p14: P14, - p15: P15, - ): R = call(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) - - public fun bind( +) : LambdaCallable(container, boundArgs), + Callable16 { + public override fun bind( p0: P0, p1: P1, p2: P2, @@ -2048,9 +1568,10 @@ public class LambdaCallable16(container, - arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, + *boundArgs)) - public fun bind( + public override fun bind( p1: P1, p2: P2, p3: P3, @@ -2067,9 +1588,9 @@ public class LambdaCallable16(container, - arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p2: P2, p3: P3, p4: P4, @@ -2085,9 +1606,9 @@ public class LambdaCallable16(container, - arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p3: P3, p4: P4, p5: P5, @@ -2102,9 +1623,9 @@ public class LambdaCallable16(container, - arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p4: P4, p5: P5, p6: P6, @@ -2118,9 +1639,9 @@ public class LambdaCallable16(container, - arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p5: P5, p6: P6, p7: P7, @@ -2133,9 +1654,9 @@ public class LambdaCallable16(container, - arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p6: P6, p7: P7, p8: P8, @@ -2147,9 +1668,9 @@ public class LambdaCallable16(container, - arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p7: P7, p8: P8, p9: P9, @@ -2160,9 +1681,9 @@ public class LambdaCallable16(container, - arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p8: P8, p9: P9, p10: P10, @@ -2172,9 +1693,9 @@ public class LambdaCallable16(container, - arrayOf(p8, p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p9: P9, p10: P10, p11: P11, @@ -2183,9 +1704,9 @@ public class LambdaCallable16(container, - arrayOf(p9, p10, p11, p12, p13, p14, p15)) + arrayOf(p9, p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p10: P10, p11: P11, p12: P12, @@ -2193,44 +1714,44 @@ public class LambdaCallable16(container, - arrayOf(p10, p11, p12, p13, p14, p15)) + arrayOf(p10, p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, ) = LambdaCallable11(container, - arrayOf(p11, p12, p13, p14, p15)) + arrayOf(p11, p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p12: P12, p13: P13, p14: P14, p15: P15, ) = LambdaCallable12(container, - arrayOf(p12, p13, p14, p15)) + arrayOf(p12, p13, p14, p15, *boundArgs)) - public fun bind( + public override fun bind( p13: P13, p14: P14, p15: P15, ) = LambdaCallable13(container, - arrayOf(p13, p14, p15)) + arrayOf(p13, p14, p15, *boundArgs)) - public fun bind(p14: P14, p15: P15) = + public override fun bind(p14: P14, p15: P15) = LambdaCallable14(container, - arrayOf(p14, p15)) + arrayOf(p14, p15, *boundArgs)) - public fun bind(p15: P15) = + public override fun bind(p15: P15) = LambdaCallable15(container, - arrayOf(p15)) + arrayOf(p15, *boundArgs)) } -public inline fun callable16(noinline function: ( +public inline fun callable16(noinline function: ( p0: P0, p1: P1, p2: P2, @@ -2250,9 +1771,9 @@ public inline fun R) = LambdaCallable16(LambdaContainer16(variantMapper.getOrDefault(R::class, NIL), arrayOf(variantMapper[P0::class]!!, variantMapper[P1::class]!!, variantMapper[P2::class]!!, variantMapper[P3::class]!!, variantMapper[P4::class]!!, variantMapper[P5::class]!!, variantMapper[P6::class]!!, variantMapper[P7::class]!!, variantMapper[P8::class]!!, variantMapper[P9::class]!!, variantMapper[P10::class]!!, variantMapper[P11::class]!!, variantMapper[P12::class]!!, variantMapper[P13::class]!!, variantMapper[P14::class]!!, variantMapper[P15::class]!!), function)) -public inline fun (( +public inline fun (( p0: P0, p1: P1, p2: P2, diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt new file mode 100644 index 000000000..d19795e06 --- /dev/null +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/MethodCallables.kt @@ -0,0 +1,1614 @@ +@file:Suppress( + "PackageDirectoryMismatch", "UNCHECKED_CAST", + "unused", +) + +package godot.core + +import godot.api.Object +import kotlin.Any +import kotlin.Array +import kotlin.PublishedApi +import kotlin.Suppress +import kotlin.reflect.KCallable + +public class MethodCallable0 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable0 + +public fun T.callable0(callable: T.() -> R) = + MethodCallable0(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable1 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable1 { + public override fun bind(p0: P0) = MethodCallable0(target, methodName, arrayOf(p0, + *boundArgs)) +} + +public fun T.callable1(callable: T.(p0: P0) -> R) = + MethodCallable1(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable2 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable2 { + public override fun bind(p0: P0, p1: P1) = MethodCallable0(target, methodName, + arrayOf(p0, p1, *boundArgs)) + + public override fun bind(p1: P1) = MethodCallable1(target, methodName, arrayOf(p1, + *boundArgs)) +} + +public fun T.callable2(callable: T.(p0: P0, p1: P1) -> R) = + MethodCallable2(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable3 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable3 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, *boundArgs)) + + public override fun bind(p1: P1, p2: P2) = MethodCallable1(target, methodName, + arrayOf(p1, p2, *boundArgs)) + + public override fun bind(p2: P2) = MethodCallable2(target, methodName, + arrayOf(p2, *boundArgs)) +} + +public fun T.callable3(callable: T.( + p0: P0, + p1: P1, + p2: P2, +) -> R) = MethodCallable3(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable4 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable4 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, *boundArgs)) + + public override fun bind(p2: P2, p3: P3) = MethodCallable2(target, methodName, + arrayOf(p2, p3, *boundArgs)) + + public override fun bind(p3: P3) = MethodCallable3(target, methodName, + arrayOf(p3, *boundArgs)) +} + +public fun T.callable4(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, +) -> R) = MethodCallable4(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable5 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable5 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, *boundArgs)) + + public override fun bind(p3: P3, p4: P4) = MethodCallable3(target, methodName, + arrayOf(p3, p4, *boundArgs)) + + public override fun bind(p4: P4) = MethodCallable4(target, methodName, + arrayOf(p4, *boundArgs)) +} + +public fun T.callable5(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, +) -> R) = + MethodCallable5(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable6 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable6 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, *boundArgs)) + + public override fun bind(p4: P4, p5: P5) = MethodCallable4(target, methodName, + arrayOf(p4, p5, *boundArgs)) + + public override fun bind(p5: P5) = MethodCallable5(target, methodName, + arrayOf(p5, *boundArgs)) +} + +public fun T.callable6(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, +) -> R) = + MethodCallable6(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable7 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable7 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, *boundArgs)) + + public override fun bind(p5: P5, p6: P6) = MethodCallable5(target, + methodName, arrayOf(p5, p6, *boundArgs)) + + public override fun bind(p6: P6) = MethodCallable6(target, methodName, + arrayOf(p6, *boundArgs)) +} + +public fun T.callable7(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, +) -> R) = + MethodCallable7(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable8 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable8 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, + *boundArgs)) + + public override fun bind(p6: P6, p7: P7) = MethodCallable6(target, + methodName, arrayOf(p6, p7, *boundArgs)) + + public override fun bind(p7: P7) = MethodCallable7(target, + methodName, arrayOf(p7, *boundArgs)) +} + +public fun T.callable8(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, +) -> R) = + MethodCallable8(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable9 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), Callable9 + { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, p8, + *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + ) = MethodCallable6(target, methodName, arrayOf(p6, p7, p8, + *boundArgs)) + + public override fun bind(p7: P7, p8: P8) = MethodCallable7(target, + methodName, arrayOf(p7, p8, *boundArgs)) + + public override fun bind(p8: P8) = MethodCallable8(target, + methodName, arrayOf(p8, *boundArgs)) +} + +public fun T.callable9(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, +) -> R) = + MethodCallable9(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable10 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable10 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable0(target, methodName, arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable1(target, methodName, arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable2(target, methodName, arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable3(target, methodName, arrayOf(p3, p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable4(target, methodName, arrayOf(p4, p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable5(target, methodName, arrayOf(p5, p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable6(target, methodName, arrayOf(p6, p7, p8, p9, + *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + ) = MethodCallable7(target, methodName, arrayOf(p7, p8, p9, + *boundArgs)) + + public override fun bind(p8: P8, p9: P9) = + MethodCallable8(target, methodName, arrayOf(p8, p9, + *boundArgs)) + + public override fun bind(p9: P9) = MethodCallable9(target, + methodName, arrayOf(p9, *boundArgs)) +} + +public fun T.callable10(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, +) -> R) = + MethodCallable10(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable11 @PublishedApi internal + constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable11 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, *boundArgs)) + + public override fun bind(p9: P9, p10: P10) = + MethodCallable9(target, methodName, + arrayOf(p9, p10, *boundArgs)) + + public override fun bind(p10: P10) = + MethodCallable10(target, methodName, + arrayOf(p10, *boundArgs)) +} + +public fun T.callable11(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, +) -> R) = + MethodCallable11(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable12 @PublishedApi + internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable12 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, *boundArgs)) + + public override fun bind(p10: P10, p11: P11) = + MethodCallable10(target, methodName, + arrayOf(p10, p11, *boundArgs)) + + public override fun bind(p11: P11) = + MethodCallable11(target, methodName, + arrayOf(p11, *boundArgs)) +} + +public fun + T.callable12(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, +) -> R) = + MethodCallable12(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable13 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable13 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, *boundArgs)) + + public override fun bind(p11: P11, p12: P12) = + MethodCallable11(target, methodName, + arrayOf(p11, p12, *boundArgs)) + + public override fun bind(p12: P12) = + MethodCallable12(target, methodName, + arrayOf(p12, *boundArgs)) +} + +public fun + T.callable13(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, +) -> R) = + MethodCallable13(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable14 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable14 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, *boundArgs)) + + public override fun bind(p12: P12, p13: P13) = + MethodCallable12(target, methodName, + arrayOf(p12, p13, *boundArgs)) + + public override fun bind(p13: P13) = + MethodCallable13(target, methodName, + arrayOf(p13, *boundArgs)) +} + +public fun + T.callable14(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, +) -> R) = + MethodCallable14(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable15 + @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable15 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, p14, *boundArgs)) + + public override fun bind( + p12: P12, + p13: P13, + p14: P14, + ) = MethodCallable12(target, methodName, + arrayOf(p12, p13, p14, *boundArgs)) + + public override fun bind(p13: P13, p14: P14) = + MethodCallable13(target, methodName, + arrayOf(p13, p14, *boundArgs)) + + public override fun bind(p14: P14) = + MethodCallable14(target, + methodName, arrayOf(p14, *boundArgs)) +} + +public fun + T.callable15(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, +) -> R) = + MethodCallable15(this, (callable as KCallable).name.toGodotName()) + +public class MethodCallable16 @PublishedApi internal constructor( + target: Object, + methodName: StringName, + boundArgs: Array = emptyArray(), +) : MethodCallable(target, methodName, boundArgs), + Callable16 { + public override fun bind( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable0(target, methodName, + arrayOf(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, + *boundArgs)) + + public override fun bind( + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable1(target, methodName, + arrayOf(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable2(target, methodName, + arrayOf(p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable3(target, methodName, + arrayOf(p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable4(target, methodName, + arrayOf(p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable5(target, methodName, + arrayOf(p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable6(target, methodName, + arrayOf(p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable7(target, methodName, + arrayOf(p7, p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable8(target, methodName, + arrayOf(p8, p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable9(target, methodName, + arrayOf(p9, p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable10(target, methodName, + arrayOf(p10, p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable11(target, methodName, + arrayOf(p11, p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p12: P12, + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable12(target, methodName, + arrayOf(p12, p13, p14, p15, *boundArgs)) + + public override fun bind( + p13: P13, + p14: P14, + p15: P15, + ) = MethodCallable13(target, methodName, + arrayOf(p13, p14, p15, *boundArgs)) + + public override fun bind(p14: P14, p15: P15) = + MethodCallable14(target, + methodName, arrayOf(p14, p15, *boundArgs)) + + public override fun bind(p15: P15) = + MethodCallable15(target, + methodName, arrayOf(p15, *boundArgs)) +} + +public fun + T.callable16(callable: T.( + p0: P0, + p1: P1, + p2: P2, + p3: P3, + p4: P4, + p5: P5, + p6: P6, + p7: P7, + p8: P8, + p9: P9, + p10: P10, + p11: P11, + p12: P12, + p13: P13, + p14: P14, + p15: P15, +) -> R) = + MethodCallable16(this, (callable as KCallable).name.toGodotName()) diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt index d49bf1a4f..f6dad3f26 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/gen/godot/core/Signals.kt @@ -18,71 +18,88 @@ import kotlin.reflect.KProperty public class Signal0 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(): Unit { emitUnsafe() } + public fun connect(connect: Callable0<*>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal0 = - Signal0(thisRef, property.name) + Signal0(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName) +public inline fun Object.Signal0(signalName: String) = Signal0(this, signalName.toGodotName()) public inline fun Object.signal0() = Signal0.delegate public class Signal1 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(p0: P0): Unit { emitUnsafe(p0) } + public fun connect(connect: Callable1<*, P0>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal1 = Signal1(thisRef, property.name) + Signal1 = Signal1(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal1(signalName: String) = Signal1(this, signalName) +public inline fun Object.Signal1(signalName: String) = + Signal1(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal1() = Signal1.delegate as ReadOnlyProperty> public class Signal2 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit(p0: P0, p1: P1): Unit { emitUnsafe(p0, p1) } + public fun connect(connect: Callable2<*, P0, P1>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal2 = Signal2(thisRef, property.name) + Signal2 = Signal2(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") -public inline fun Object.Signal2(signalName: String) = Signal2(this, signalName) +public inline fun Object.Signal2(signalName: String) = + Signal2(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal2() = @@ -90,7 +107,7 @@ public inline fun Object.signal2() = public class Signal3 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -100,19 +117,24 @@ public class Signal3 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2) } + public fun connect(connect: Callable3<*, P0, P1, P2>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal3 = Signal3(thisRef, property.name) + Signal3 = Signal3(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal3(signalName: String) = - Signal3(this, signalName) + Signal3(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal3() = @@ -120,7 +142,7 @@ public inline fun Object.signal3() = public class Signal4 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -131,19 +153,25 @@ public class Signal4 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3) } + public fun connect(connect: Callable4<*, P0, P1, P2, P3>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = ReadOnlyProperty { thisRef, property -> getValue(thisRef, property) } public inline operator fun getValue(thisRef: Object, - `property`: KProperty<*>): Signal4 = Signal4(thisRef, property.name) + `property`: KProperty<*>): Signal4 = + Signal4(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal4(signalName: String) = - Signal4(this, signalName) + Signal4(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal4() = @@ -151,7 +179,7 @@ public inline fun Object.signal4() = public class Signal5 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -163,6 +191,11 @@ public class Signal5 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3, p4) } + public fun connect(connect: Callable5<*, P0, P1, P2, P3, P4>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = @@ -170,13 +203,13 @@ public class Signal5 @PublishedApi internal constructor( public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal5 = - Signal5(thisRef, property.name) + Signal5(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal5(signalName: String) = - Signal5(this, signalName) + Signal5(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal5() = @@ -184,7 +217,7 @@ public inline fun Object.signal5() = public class Signal6 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -197,6 +230,11 @@ public class Signal6 @PublishedApi internal constructor( emitUnsafe(p0, p1, p2, p3, p4, p5) } + public fun connect(connect: Callable6<*, P0, P1, P2, P3, P4, P5>, flags: Object.ConnectFlags = + Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: ReadOnlyProperty> = @@ -204,13 +242,13 @@ public class Signal6 @PublishedApi internal constructor( public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal6 = - Signal6(thisRef, property.name) + Signal6(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal6(signalName: String) = - Signal6(this, signalName) + Signal6(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal6() = @@ -218,7 +256,7 @@ public inline fun Object.signal6() = public class Signal7 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -232,6 +270,11 @@ public class Signal7 @PublishedApi internal construc emitUnsafe(p0, p1, p2, p3, p4, p5, p6) } + public fun connect(connect: Callable7<*, P0, P1, P2, P3, P4, P5, P6>, flags: Object.ConnectFlags + = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -240,13 +283,13 @@ public class Signal7 @PublishedApi internal construc public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal7 = - Signal7(thisRef, property.name) + Signal7(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal7(signalName: String) = - Signal7(this, signalName) + Signal7(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal7() = @@ -254,7 +297,7 @@ public inline fun Object.signal7() = public class Signal8 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -269,6 +312,11 @@ public class Signal8 @PublishedApi internal cons emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7) } + public fun connect(connect: Callable8<*, P0, P1, P2, P3, P4, P5, P6, P7>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -277,13 +325,13 @@ public class Signal8 @PublishedApi internal cons public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal8 = - Signal8(thisRef, property.name) + Signal8(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal8(signalName: String) = - Signal8(this, signalName) + Signal8(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal8() = @@ -291,7 +339,7 @@ public inline fun Object.signal8() = public class Signal9 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -307,6 +355,11 @@ public class Signal9 @PublishedApi internal emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8) } + public fun connect(connect: Callable9<*, P0, P1, P2, P3, P4, P5, P6, P7, P8>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -315,13 +368,13 @@ public class Signal9 @PublishedApi internal public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal9 = - Signal9(thisRef, property.name) + Signal9(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal9(signalName: String) = - Signal9(this, signalName) + Signal9(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal9() = @@ -329,7 +382,7 @@ public inline fun Object.signal9() = public class Signal10 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -346,6 +399,11 @@ public class Signal10 @PublishedApi inte emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) } + public fun connect(connect: Callable10<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -354,13 +412,14 @@ public class Signal10 @PublishedApi inte public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): - Signal10 = Signal10(thisRef, property.name) + Signal10 = + Signal10(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal10(signalName: String) = - Signal10(this, signalName) + Signal10(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal10() = @@ -369,7 +428,7 @@ public inline fun Object.signal10() = public class Signal11 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -387,6 +446,11 @@ public class Signal11 @PublishedApi emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) } + public fun connect(connect: Callable11<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -396,13 +460,13 @@ public class Signal11 @PublishedApi public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal11 = - Signal11(thisRef, property.name) + Signal11(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal11(signalName: String) - = Signal11(this, signalName) + = Signal11(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal11() = @@ -411,7 +475,7 @@ public inline fun Object.signal11( public class Signal12 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -430,6 +494,11 @@ public class Signal12 @Publish emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) } + public fun connect(connect: Callable12<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -439,14 +508,14 @@ public class Signal12 @Publish public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal12 = - Signal12(thisRef, property.name) + Signal12(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal12(signalName: String) = - Signal12(this, signalName) + Signal12(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal12() = @@ -455,7 +524,7 @@ public inline fun Object.sign public class Signal13 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -475,6 +544,12 @@ public class Signal13 @Pu emitUnsafe(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) } + public + fun connect(connect: Callable13<*, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -484,14 +559,14 @@ public class Signal13 @Pu public inline operator fun getValue(thisRef: Object, `property`: KProperty<*>): Signal13 = - Signal13(thisRef, property.name) + Signal13(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal13(signalName: String) = - Signal13(this, signalName) + Signal13(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal13() = @@ -500,7 +575,7 @@ public inline fun Object public class Signal14 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -521,6 +596,12 @@ public class Signal14, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -530,14 +611,14 @@ public class Signal14 getValue(thisRef: Object, `property`: KProperty<*>): Signal14 = - Signal14(thisRef, property.name) + Signal14(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal14(signalName: String) = - Signal14(this, signalName) + Signal14(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun Object.signal14() = @@ -546,7 +627,7 @@ public inline fun O public class Signal15 @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -568,6 +649,12 @@ public class Signal15, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -577,14 +664,14 @@ public class Signal15 getValue(thisRef: Object, `property`: KProperty<*>): Signal15 = - Signal15(thisRef, property.name) + Signal15(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal15(signalName: String) = - Signal15(this, signalName) + Signal15(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun @@ -594,7 +681,7 @@ public inline fun @PublishedApi internal constructor( instance: Object, - name: String, + name: StringName, ) : Signal(instance, name) { public fun emit( p0: P0, @@ -617,6 +704,12 @@ public class Signal16, + flags: Object.ConnectFlags = Object.ConnectFlags.DEFAULT): Unit { + connectUnsafe(connect, flags) + } + public companion object { @PublishedApi internal val `delegate`: @@ -626,14 +719,14 @@ public class Signal16 getValue(thisRef: Object, `property`: KProperty<*>): Signal16 = - Signal16(thisRef, property.name) + Signal16(thisRef, property.toGodotName()) } } @Suppress("FUNCTION_NAME") public inline fun Object.Signal16(signalName: String) = - Signal16(this, signalName) + Signal16(this, signalName.toGodotName()) @Suppress("UNCHECKED_CAST") public inline fun diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt index 358667182..8f4f5c732 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/Variant.kt @@ -5,7 +5,6 @@ import godot.common.interop.ObjectID import godot.common.interop.VariantConverter import godot.common.interop.nullptr import godot.common.util.toRealT -import godot.core.Signal import godot.internal.memory.LongStringQueue import java.nio.ByteBuffer @@ -373,14 +372,9 @@ enum class VariantParser(override val id: Int) : VariantConverter { CALLABLE(25) { override fun toUnsafeKotlin(buffer: ByteBuffer) = VariantCallable(buffer.long) override fun toUnsafeGodot(buffer: ByteBuffer, any: Any?) { - if (any is VariantCallable) { - buffer.putLong(any.ptr) - } else { - require(any is LambdaCallable<*> || any is MethodCallable) - // Be careful that ::toNativeCallable doesn't itself use the shared buffer. - val ptr = any.toNativeCallable().ptr - buffer.putLong(ptr) - } + require(any is Callable) + // Be careful that ::toNativeCallable doesn't itself use the shared buffer. + buffer.putLong(any.toNativeCallable().ptr) } }, SIGNAL(26) { diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt index bb8449fe0..51761a21b 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/LambdaCallable.kt @@ -10,7 +10,7 @@ import godot.internal.memory.TransferContext open class LambdaCallable internal constructor( protected val container: LambdaContainer, - private var boundArgs: Array = emptyArray() + protected var boundArgs: Array = emptyArray() ) : Callable { override fun getBoundArguments() = boundArgs.toList() diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt index 9bd2fd6b7..e8d225b37 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/MethodCallable.kt @@ -6,12 +6,14 @@ import godot.api.Object import godot.core.Callable.Bridge import godot.internal.memory.MemoryManager -class MethodCallable internal constructor( - private val target: Object, - private val methodName: StringName, - private var boundArgs: Array = emptyArray() +open class MethodCallable internal constructor( + protected val target: Object, + protected val methodName: StringName, + protected var boundArgs: Array = emptyArray() ) : Callable { + constructor(target: Object, methodName: StringName) : this(target, methodName, emptyArray()) + override fun getBoundArguments() = boundArgs.toList() override fun getBoundArgumentCount() = boundArgs.size override fun getMethod() = methodName @@ -39,10 +41,4 @@ class MethodCallable internal constructor( } return unbound } - - companion object { - @JvmStatic - @JvmName("create") - operator fun invoke(target: Object, methodName: StringName) = MethodCallable(target, methodName) - } } diff --git a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt index 4230fad72..cdd830a58 100644 --- a/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt +++ b/kt/godot-library/godot-core-library/src/main/kotlin/godot/core/callback/Signal.kt @@ -12,11 +12,6 @@ open class Signal internal constructor( val name: StringName ) : CoreType { - internal constructor(instance: Object, jvmName: String) : this( - instance, - jvmName.convertToSnakeCase().asStringName() - ) - fun emitUnsafe(vararg args: Any?) { godotObject.emitSignal(name, *args) } diff --git a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt index 525397f68..18719f2e2 100644 --- a/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt +++ b/kt/tools-common/src/main/kotlin/godot/tools/common/constants/Classes.kt @@ -255,6 +255,7 @@ val GODOT_LAMBDA_CALLABLE = ClassName(godotCorePackage, GodotKotlinJvmTypes.lamb val GODOT_DICTIONARY = ClassName(godotCorePackage, GodotKotlinJvmTypes.dictionary) val GODOT_OBJECT = ClassName(godotApiPackage, GodotKotlinJvmTypes.obj) val KT_OBJECT = ClassName(godotCorePackage, GodotKotlinJvmTypes.ktObject) +val STRING_NAME = ClassName(godotCorePackage, GodotKotlinJvmTypes.stringName) val VARIANT_PARSER_NIL = ClassName(variantParserPackage, "NIL") val VARIANT_PARSER_BOOL = ClassName(variantParserPackage, "BOOL")