Merge pull request #9 from k163377/single_arg_fastkfunction

k163377 · web-flow · commit 220a73cfc639 · 2020-12-06T15:31:52.000+09:00
Add SingleArgFastKFunction.
diff --git a/README.md b/README.md
@@ -93,7 +93,7 @@ data class Sample(
     val arg3: String? = null
 )
 
-private val fastKFunction: FastKFunction<Sample> = FastKFunction.of(::Sample)
+val fastKFunction: FastKFunction<Sample> = FastKFunction.of(::Sample)
 
 fun map(src: Map<String, Any?>): Sample {
     return fastKFunction.generateBucket()
@@ -105,6 +105,17 @@ fun map(src: Map<String, Any?>): Sample {
 }
 ```
 
+### For functions that can be called from a single argument.
+For a function that can be called with a single argument, you can use the `SingleArgFastKFunction`.
+
+```kotlin
+data class Sample(val arg: Int)
+
+val fastKFunction: SingleArgFastKFunction<Sample> = SingleArgFastKFunction.of(::Sample)
+
+val result: Sample = fastKFunction.call(1)
+```
+
 ## Benchmark
 You can run the benchmark with the `./gradlew jmh`.  
 Please note that it will take about 2 hours in total if executed with the default settings.
diff --git a/src/main/kotlin/com/mapk/fastkfunction/FastKFunction.kt b/src/main/kotlin/com/mapk/fastkfunction/FastKFunction.kt
@@ -129,11 +129,13 @@ sealed class FastKFunction<T> {
     }
 
     companion object {
-        private fun List<KParameter>.checkParameters(instance: Any?) = also {
-            if (isEmpty() || (instance != null && size == 1))
+        private fun List<KParameter>.checkParameters() = also {
+            val requireInstanceParameter = this[0].kind != KParameter.Kind.VALUE
+
+            if (isEmpty() || (requireInstanceParameter && size == 1))
                 throw IllegalArgumentException("This function is not require arguments.")
 
-            if (3 <= size && get(0).kind != KParameter.Kind.VALUE && get(1).kind != KParameter.Kind.VALUE)
+            if (3 <= size && requireInstanceParameter && get(1).kind != KParameter.Kind.VALUE)
                 throw IllegalArgumentException("This function is require multiple instances.")
         }
 
@@ -191,7 +193,7 @@ sealed class FastKFunction<T> {
 
         fun <T> of(function: KFunction<T>, instance: Any? = null): FastKFunction<T> {
             // 引数を要求しないか、複数のインスタンスを求める場合エラーとする
-            val parameters: List<KParameter> = function.parameters.checkParameters(instance)
+            val parameters: List<KParameter> = function.parameters.checkParameters()
 
             // この関数には確実にアクセスするためアクセシビリティ書き換え
             function.isAccessible = true
diff --git a/src/main/kotlin/com/mapk/fastkfunction/SingleArgFastKFunction.kt b/src/main/kotlin/com/mapk/fastkfunction/SingleArgFastKFunction.kt
@@ -0,0 +1,133 @@
+package com.mapk.fastkfunction
+
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import kotlin.reflect.KFunction
+import kotlin.reflect.KParameter
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaConstructor
+import kotlin.reflect.jvm.javaMethod
+import java.lang.reflect.Constructor as JavaConstructor
+
+sealed class SingleArgFastKFunction<T> {
+    abstract val valueParameter: KParameter
+    abstract fun call(arg: Any?): T
+
+    internal class Constructor<T>(
+        override val valueParameter: KParameter,
+        private val constructor: JavaConstructor<T>
+    ) : SingleArgFastKFunction<T>() {
+        override fun call(arg: Any?): T = constructor.newInstance(arg)
+    }
+
+    internal class Function<T>(
+        override val valueParameter: KParameter,
+        private val function: KFunction<T>
+    ) : SingleArgFastKFunction<T>() {
+        override fun call(arg: Any?): T = function.call(arg)
+    }
+
+    internal class TopLevelFunction<T>(
+        override val valueParameter: KParameter,
+        private val method: Method
+    ) : SingleArgFastKFunction<T>() {
+        @Suppress("UNCHECKED_CAST")
+        override fun call(arg: Any?): T = method.invoke(null, arg) as T
+    }
+
+    internal class TopLevelExtensionFunction<T>(
+        override val valueParameter: KParameter,
+        private val method: Method,
+        private val extensionReceiver: Any
+    ) : SingleArgFastKFunction<T>() {
+        @Suppress("UNCHECKED_CAST")
+        override fun call(arg: Any?): T = method.invoke(null, extensionReceiver, arg) as T
+    }
+
+    internal class InstanceFunction<T>(
+        override val valueParameter: KParameter,
+        private val method: Method,
+        private val instance: Any
+    ) : SingleArgFastKFunction<T>() {
+        @Suppress("UNCHECKED_CAST")
+        override fun call(arg: Any?): T = method.invoke(instance, arg) as T
+    }
+
+    companion object {
+        private fun List<KParameter>.checkParameters() = also {
+            val requireInstanceParameter = this[0].kind != KParameter.Kind.VALUE
+
+            if (isEmpty() || (requireInstanceParameter && size == 1))
+                throw IllegalArgumentException("This function is not require arguments.")
+
+            if (!(this.size == 1 || (this.size == 2 && requireInstanceParameter)))
+                throw IllegalArgumentException("This function is require multiple arguments.")
+        }
+
+        private fun <T> topLevelFunctionOf(
+            function: KFunction<T>,
+            instance: Any?,
+            parameters: List<KParameter>,
+            method: Method
+        ): SingleArgFastKFunction<T> = when {
+            // KParameter.Kind.EXTENSION_RECEIVERの要求が有れば確定で拡張関数
+            parameters[0].kind == KParameter.Kind.EXTENSION_RECEIVER -> {
+                // 対象が拡張関数ならinstanceはreceiver、指定が無ければエラー
+                instance ?: throw IllegalArgumentException(
+                    "Function requires EXTENSION_RECEIVER instance, but is not present."
+                )
+
+                TopLevelExtensionFunction(parameters[1], method, instance)
+            }
+            // javaMethodのパラメータサイズとKFunctionのパラメータサイズが違う場合も拡張関数
+            // インスタンスが設定されていれば高速呼び出し、そうじゃなければ通常の関数呼び出し
+            method.parameters.size != parameters.size ->
+                instance
+                    ?.let { TopLevelExtensionFunction(parameters[0], method, instance) }
+                    ?: Function(parameters[0], function)
+            // トップレベル関数
+            else -> TopLevelFunction(parameters[0], method)
+        }
+
+        private fun <T> instanceFunctionOf(
+            function: KFunction<T>,
+            inputtedInstance: Any?,
+            parameters: List<KParameter>,
+            method: Method
+        ): SingleArgFastKFunction<T> {
+            val instance = inputtedInstance ?: method.declaringObject
+
+            return when {
+                parameters[0].kind == KParameter.Kind.INSTANCE ->
+                    instance
+                        ?.let { InstanceFunction(parameters[1], method, it) }
+                        ?: throw IllegalArgumentException("Function requires INSTANCE parameter, but is not present.")
+                instance != null -> InstanceFunction(parameters[0], method, instance)
+                else -> Function(parameters[0], function)
+            }
+        }
+
+        fun <T> of(function: KFunction<T>, instance: Any? = null): SingleArgFastKFunction<T> {
+            // 引数を要求しないか、複数のインスタンスを求める場合エラーとする
+            val parameters: List<KParameter> = function.parameters.checkParameters()
+
+            // この関数には確実にアクセスするためアクセシビリティ書き換え
+            function.isAccessible = true
+
+            val constructor = function.javaConstructor
+
+            return if (constructor != null) {
+                Constructor(parameters[0], constructor)
+            } else {
+                val method = function.javaMethod!!
+
+                // Methodがstatic関数ならfunctionはトップレベル関数
+                if (Modifier.isStatic(method.modifiers)) {
+                    topLevelFunctionOf(function, instance, parameters, method)
+                } else {
+                    instanceFunctionOf(function, instance, parameters, method)
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/kotlin/com/mapk/fastkfunction/singleargfastkfunction/SingleArgFastKFunctionTest.kt b/src/test/kotlin/com/mapk/fastkfunction/singleargfastkfunction/SingleArgFastKFunctionTest.kt
@@ -0,0 +1,80 @@
+package com.mapk.fastkfunction.singleargfastkfunction
+
+import com.mapk.fastkfunction.SingleArgFastKFunction
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import java.util.stream.Stream
+import kotlin.reflect.KFunction
+import kotlin.reflect.full.companionObject
+import kotlin.reflect.full.companionObjectInstance
+import kotlin.reflect.full.functions
+
+private fun topLevelFunc(arg: Int): SingleArgSingleArgFastKFunctionTest.Dst = SingleArgSingleArgFastKFunctionTest.Dst(arg)
+private fun SingleArgSingleArgFastKFunctionTest.Class.topLevelExtensionFunc(arg: Int): SingleArgSingleArgFastKFunctionTest.Dst =
+    SingleArgSingleArgFastKFunctionTest.Dst(this.arg + arg)
+
+/**
+ * 網羅しているパターン
+ * - コンストラクタ
+ * - インスタンスメソッド
+ * - インスタンスメソッド + インスタンス
+ * - コンパニオンオブジェクトに定義したメソッド
+ * - コンパニオンオブジェクトに定義したメソッド + コンパニオンオブジェクトインスタンス
+ * - リフレクションで取得したコンパニオンオブジェクトに定義したメソッド
+ * - リフレクションで取得したコンパニオンオブジェクトに定義したメソッド + コンパニオンオブジェクトインスタンス
+ * - トップレベル関数
+ * - クラスから取得したトップレベル拡張関数 + レシーバインスタンス
+ * - インスタンスから取得したトップレベル拡張関数
+ * - インスタンスから取得したトップレベル拡張関数 + インスタンス
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+private class SingleArgSingleArgFastKFunctionTest {
+    class Class(val arg: Int)
+
+    data class Dst(val arg: Int) {
+        companion object {
+            fun of(arg: Int) = Dst(arg)
+        }
+    }
+
+    private fun instanceFunction(arg: Int) = Dst(arg)
+
+    @ParameterizedTest
+    @MethodSource("argumentsProvider")
+    fun call(target: KFunction<Dst>, instance: Any?, message: String) {
+        val sut = SingleArgFastKFunction.of(target, instance)
+        assertDoesNotThrow("Fail $message") {
+            Assertions.assertEquals(Dst(100), sut.call(100), message)
+        }
+    }
+
+    fun argumentsProvider(): Stream<Arguments> {
+        val companionRawFunc = Dst::class.companionObject!!.functions.first { it.name == "of" }
+
+        return listOf(
+            Arguments.of(::Dst, null, "constructor"),
+            Arguments.of(::instanceFunction, null, "instance func"),
+            Arguments.of(::instanceFunction, this, "instance func with instance"),
+            Arguments.of((Dst)::of, null, "companion object func"),
+            Arguments.of((Dst)::of, Dst::class.companionObjectInstance, "companion object func with instance"),
+            Arguments.of(companionRawFunc, null, "companion object func from reflection"),
+            Arguments.of(
+                companionRawFunc,
+                Dst::class.companionObjectInstance,
+                "companion object func from reflection with instance"
+            ),
+            Arguments.of(::topLevelFunc, null, "top level func"),
+            Arguments.of(Class::topLevelExtensionFunc, Class(0), "top level extension func from class"),
+            Class(0).let {
+                Arguments.of(it::topLevelExtensionFunc, null, "top level extension func from instance")
+            },
+            Class(0).let {
+                Arguments.of(it::topLevelExtensionFunc, it, "top level extension func from instance with instance")
+            }
+        ).stream()
+    }
+}
