Merge pull request #13 from k163377/feature

Improved memory usage efficiency and update libraries.

Author: k163377

.idea/KRowMapper.iml

@@ -1,12 +1,12 @@
 plugins {
     id("maven")
     id("java")
-    id("org.jetbrains.kotlin.jvm") version "1.3.71"
+    id("org.jetbrains.kotlin.jvm") version "1.3.72"
     id("org.jlleitschuh.gradle.ktlint") version "9.2.1"
 }
 
 group = "com.mapk"
-version = "0.8"
+version = "0.9"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
@@ -18,7 +18,7 @@ buildscript {
     }
 
     dependencies {
-        classpath(kotlin("gradle-plugin", version = "1.3.71"))
+        classpath(kotlin("gradle-plugin"))
     }
 }
 
@@ -30,7 +30,7 @@ repositories {
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     implementation(kotlin("reflect"))
-    api("com.github.ProjectMapK:Shared:0.10")
+    api("com.github.ProjectMapK:Shared:0.11")
     // 使うのはRowMapperのみなため他はexclude、またバージョンそのものは使う相手に合わせるためcompileOnly
     compileOnly(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE") {
         exclude(module = "spring-beans")
@@ -39,7 +39,7 @@ dependencies {
     }
 
     // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter
-    testImplementation(group = "org.junit.jupiter", name = "junit-jupiter", version = "5.6.1") {
+    testImplementation(group = "org.junit.jupiter", name = "junit-jupiter", version = "5.6.2") {
         exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
     }
     // https://mvnrepository.com/artifact/io.mockk/mockk

.idea/compiler.xml

@@ -19,55 +19,64 @@ import kotlin.reflect.full.staticFunctions
 import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.jvm.jvmName
 
-internal class ParameterForMap private constructor(
-    val param: KParameter,
-    name: String,
-    parameterKClazz: KClass<*>
-) {
-    private val objectGetter: (ResultSet) -> Any?
-
-    init {
-        val deserializerFromParameter = param.getDeserializer()
-        if (deserializerFromParameter != null) {
-            val deserialize = deserializerFromParameter::deserialize
-
-            objectGetter = {
-                deserialize.call(it.getObject(name, deserializerFromParameter.srcClass))
-            }
-        } else {
-            val deserializer = parameterKClazz.getDeserializer()
-
-            if (deserializer != null) {
-                val targetClass = deserializer.parameters.single().type.classifier as KClass<*>
+internal sealed class ParameterForMap {
+    abstract val param: KParameter
+    abstract val name: String
+    abstract val clazz: Class<*>
+    abstract fun getObject(rs: ResultSet): Any?
+
+    private class Plain(
+        override val param: KParameter,
+        override val name: String,
+        override val clazz: Class<*>
+    ) : ParameterForMap() {
+        override fun getObject(rs: ResultSet): Any? = rs.getObject(name, clazz)
+    }
 
-                objectGetter = {
-                    deserializer.call(it.getObject(name, targetClass.javaObjectType))
-                }
-            } else {
-                val clazz = parameterKClazz.javaObjectType
-
-                objectGetter = if (clazz.isEnum) {
-                    {
-                        EnumMapper.getEnum(clazz, it.getString(name))
-                    }
-                } else {
-                    {
-                        it.getObject(name, clazz)
-                    }
-                }
-            }
-        }
+    private class Enum(
+        override val param: KParameter,
+        override val name: String,
+        override val clazz: Class<*>
+    ) : ParameterForMap() {
+        override fun getObject(rs: ResultSet): Any? = EnumMapper.getEnum(clazz, rs.getString(name))
     }
 
-    fun getObject(rs: ResultSet): Any? = objectGetter(rs)
+    private class Deserializer(
+        override val param: KParameter,
+        override val name: String,
+        override val clazz: Class<*>,
+        private val deserializer: KFunction<*>
+    ) : ParameterForMap() {
+        constructor(
+            param: KParameter,
+            name: String,
+            deserializer: AbstractKColumnDeserializer<*, *, *>
+        ) : this(param, name, deserializer.srcClass, deserializer::deserialize)
+
+        override fun getObject(rs: ResultSet): Any? = deserializer.call(rs.getObject(name, clazz))
+    }
 
     companion object {
         fun newInstance(param: KParameter, parameterNameConverter: (String) -> String): ParameterForMap {
-            return ParameterForMap(
-                param,
-                parameterNameConverter(param.getAliasOrName()!!),
-                param.type.classifier as KClass<*>
-            )
+            val name = parameterNameConverter(param.getAliasOrName()!!)
+
+            param.getDeserializer()?.let {
+                return Deserializer(param, name, it)
+            }
+
+            val parameterKClazz = param.type.classifier as KClass<*>
+
+            parameterKClazz.getDeserializer()?.let {
+                val targetClass = (it.parameters.single().type.classifier as KClass<*>).javaObjectType
+                return Deserializer(param, name, targetClass, it)
+            }
+
+            return parameterKClazz.javaObjectType.let {
+                when (it.isEnum) {
+                    true -> Enum(param, name, it)
+                    false -> Plain(param, name, it)
+                }
+            }
         }
     }
 }