Replace BooleanTriState with OptBoolean

release-notes/CREDITS-2.x

@@ -18,6 +18,7 @@ Contributors:
 # 2.19.0 (not yet released)
 
 WrongWrong (@k163377)
+* #954: Replace BooleanTriState with OptBoolean
 * #944: Fixed to use common util for Member accessibility override
 * #937: Added type match check to read functions
 

release-notes/VERSION-2.x

@@ -18,6 +18,7 @@ Co-maintainers:
 
 2.19.0 (not yet released)
 
+#954: Replaced `OptBoolean` of internal caching with a common implementation.
 #944: Common util is now used for member accessibility overrides.
 #937: For `readValue` and other shorthands for `ObjectMapper` deserialization methods,
   type consistency checks have been added.

src/main/kotlin/com/fasterxml/jackson/module/kotlin/ReflectionCache.kt

@@ -1,5 +1,6 @@
 package com.fasterxml.jackson.module.kotlin
 
+import com.fasterxml.jackson.annotation.OptBoolean
 import com.fasterxml.jackson.databind.introspect.AnnotatedConstructor
 import com.fasterxml.jackson.databind.introspect.AnnotatedMember
 import com.fasterxml.jackson.databind.introspect.AnnotatedMethod
@@ -22,32 +23,12 @@ import kotlin.reflect.jvm.kotlinFunction
 internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
     companion object {
         // Increment is required when properties that use LRUMap are changed.
-        private const val serialVersionUID = 3L
-    }
-
-    sealed class BooleanTriState(val value: Boolean?) {
-        class True : BooleanTriState(true)
-        class False : BooleanTriState(false)
-        class Empty : BooleanTriState(null)
-
-        companion object {
-            private val TRUE = True()
-            private val FALSE = False()
-            private val EMPTY = Empty()
-
-            fun fromBoolean(value: Boolean?): BooleanTriState {
-                return when (value) {
-                    null -> EMPTY
-                    true -> TRUE
-                    false -> FALSE
-                }
-            }
-        }
+        private const val serialVersionUID = 4L
     }
 
     private val javaExecutableToKotlin = LRUMap<Executable, KFunction<*>>(reflectionCacheSize, reflectionCacheSize)
     private val javaExecutableToValueCreator = LRUMap<Executable, ValueCreator<*>>(reflectionCacheSize, reflectionCacheSize)
-    private val javaMemberIsRequired = LRUMap<AnnotatedMember, BooleanTriState?>(reflectionCacheSize, reflectionCacheSize)
+    private val javaMemberIsRequired = LRUMap<AnnotatedMember, OptBoolean?>(reflectionCacheSize, reflectionCacheSize)
 
     // Initial size is 0 because the value class is not always used
     private val valueClassReturnTypeCache: LRUMap<AnnotatedMethod, Optional<KClass<*>>> =
@@ -102,8 +83,8 @@ internal class ReflectionCache(reflectionCacheSize: Int) : Serializable {
         )
     } // we cannot reflect this method so do the default Java-ish behavior
 
-    fun javaMemberIsRequired(key: AnnotatedMember, calc: (AnnotatedMember) -> Boolean?): Boolean? = javaMemberIsRequired.get(key)?.value
-            ?: calc(key).let { javaMemberIsRequired.putIfAbsent(key, BooleanTriState.fromBoolean(it))?.value ?: it }
+    fun javaMemberIsRequired(key: AnnotatedMember, calc: (AnnotatedMember) -> Boolean?): Boolean? = javaMemberIsRequired.get(key)?.asBoolean()
+            ?: calc(key).let { javaMemberIsRequired.putIfAbsent(key, OptBoolean.fromBoolean(it))?.asBoolean() ?: it }
 
     private fun AnnotatedMethod.getValueClassReturnType(): KClass<*>? {
         val getter = this.member.apply {