バケツクラスを用いるように修正

Author: k163377

src/main/kotlin/com/wrongwrong/mapk/core/KMapper.kt

@@ -40,64 +40,90 @@ class KMapper<T : Any> private constructor(
         if (parameterMap.isEmpty()) throw IllegalArgumentException("This function is not require arguments.")
     }
 
-    private fun bindParameters(targetBucket: Array<Any?>, src: Any) {
+    private fun throwExceptionOnNotInitialized(argumentBucket: ArgumentBucket): Nothing {
+        val notInitializedIndexes = argumentBucket.notInitializedParameterIndexes
+        function.parameters
+            .filter { it.index in notInitializedIndexes }
+            .map { it.name }
+            .joinToString(", ")
+            .let {
+                throw IllegalArgumentException("Not passed arguments: $it")
+            }
+    }
+
+    private fun bindArguments(argumentBucket: ArgumentBucket, src: Any) {
         src::class.memberProperties.forEach { property ->
             val javaGetter: Method? = property.javaGetter
             if (javaGetter != null && property.visibility == KVisibility.PUBLIC && property.annotations.none { annotation -> annotation is KPropertyIgnore }) {
                 parameterMap[property.findAnnotation<KGetterAlias>()?.value ?: property.name]?.let {
                     // javaGetterを呼び出す方が高速
                     javaGetter.isAccessible = true
-                    targetBucket[it.index] = javaGetter.invoke(src)?.let { value -> mapObject(it, value) }
+                    argumentBucket.setArgument(javaGetter.invoke(src)?.let { value -> mapObject(it, value) }, it.index)
+                    // 終了判定
+                    if (argumentBucket.isInitialized) return
                 }
             }
         }
     }
 
-    private fun bindParameters(targetBucket: Array<Any?>, src: Map<*, *>) {
+    private fun bindArguments(argumentBucket: ArgumentBucket, src: Map<*, *>) {
         src.forEach { (key, value) ->
             parameterMap[key]?.let { param ->
                 // 取得した内容がnullでなければ適切にmapする
-                targetBucket[param.index] = value?.let { mapObject(param, it) }
+                argumentBucket.setArgument(value?.let { mapObject(param, it) }, param.index)
+                // 終了判定
+                if (argumentBucket.isInitialized) return
             }
         }
     }
 
-    private fun bindParameters(targetBucket: Array<Any?>, srcPair: Pair<*, *>) {
-        parameterMap.getValue(srcPair.first.toString()).let {
-            targetBucket[it.index] = srcPair.second?.let { value -> mapObject(it, value) }
+    private fun bindArguments(argumentBucket: ArgumentBucket, srcPair: Pair<*, *>) {
+        parameterMap[srcPair.first.toString()]?.let {
+            argumentBucket.setArgument(srcPair.second?.let { value -> mapObject(it, value) }, it.index)
         }
     }
 
     fun map(srcMap: Map<String, Any?>): T {
-        val bucket: Array<Any?> = function.argumentBucket
-        bindParameters(bucket, srcMap)
+        val bucket: ArgumentBucket = function.getArgumentBucket()
+        bindArguments(bucket, srcMap)
+
+        if (!bucket.isInitialized) throwExceptionOnNotInitialized(bucket)
+
         return function.call(bucket)
     }
 
     fun map(srcPair: Pair<String, Any?>): T {
-        val bucket: Array<Any?> = function.argumentBucket
-        bindParameters(bucket, srcPair)
+        val bucket: ArgumentBucket = function.getArgumentBucket()
+        bindArguments(bucket, srcPair)
+
+        if (!bucket.isInitialized) throwExceptionOnNotInitialized(bucket)
+
         return function.call(bucket)
     }
 
     fun map(src: Any): T {
-        val bucket: Array<Any?> = function.argumentBucket
-        bindParameters(bucket, src)
+        val bucket: ArgumentBucket = function.getArgumentBucket()
+        bindArguments(bucket, src)
+
+        if (!bucket.isInitialized) throwExceptionOnNotInitialized(bucket)
+
         return function.call(bucket)
     }
 
     fun map(vararg args: Any): T {
-        val array: Array<Any?> = function.argumentBucket
+        val bucket: ArgumentBucket = function.getArgumentBucket()
 
         listOf(*args).forEach { arg ->
             when (arg) {
-                is Map<*, *> -> bindParameters(array, arg)
-                is Pair<*, *> -> bindParameters(array, arg)
-                else -> bindParameters(array, arg)
+                is Map<*, *> -> bindArguments(bucket, arg)
+                is Pair<*, *> -> bindArguments(bucket, arg)
+                else -> bindArguments(bucket, arg)
             }
         }
 
-        return function.call(array)
+        if (!bucket.isInitialized) throwExceptionOnNotInitialized(bucket)
+
+        return function.call(bucket)
     }
 }