Rename CBF to Cbf, Add Any constraint to BinarySerializer T

Author: NichtStudioCode

cosmic-binary-format/src/jmh/kotlin/benchmark/MapSerializerBenchmark.kt

@@ -7,7 +7,7 @@ import org.openjdk.jmh.annotations.OutputTimeUnit
 import org.openjdk.jmh.annotations.Scope
 import org.openjdk.jmh.annotations.Setup
 import org.openjdk.jmh.annotations.State
-import xyz.xenondevs.cbf.CBF
+import xyz.xenondevs.cbf.Cbf
 import java.util.concurrent.TimeUnit
 import kotlin.random.Random
 
@@ -58,27 +58,27 @@ open class MapSerializerBenchmark {
 
     @Benchmark
     fun serializeMap10() {
-        CBF.write(map10)
+        Cbf.write(map10)
     }
 
     @Benchmark
     fun serializeMap1k() {
-        CBF.write(map1k)
+        Cbf.write(map1k)
     }
 
     @Benchmark
     fun serializeMap1m() {
-        CBF.write(map1m)
+        Cbf.write(map1m)
     }
 
     @Benchmark
     fun serializeNestedMap10() {
-        CBF.write(nestedMap10)
+        Cbf.write(nestedMap10)
     }
 
     @Benchmark
     fun serializeNestedMap1k() {
-        CBF.write(nestedMap1k)
+        Cbf.write(nestedMap1k)
     }
 
 }

cosmic-binary-format/src/main/kotlin/xyz/xenondevs/cbf/CBFSecurityManager.kt

@@ -5,22 +5,22 @@ import kotlin.reflect.KType
 
 /**
  * The security manager is responsible for controlling the creation of serializers.
- * 
+ *
  * For example, in environments with a plugin system, the security manager can be used to prevent plugins from registering serializers
  * for third-party types, preventing multiple serializers with different formats from existing.
  */
-interface CBFSecurityManager {
+interface CbfSecurityManager {
 
     /**
      * Checks whether the given [serializer] for [type] is allowed to be registered.
      */
-    fun <T> isAllowed(type: KType, serializer: BinarySerializer<T>): Boolean
+    fun <T : Any> isAllowed(type: KType, serializer: BinarySerializer<T>): Boolean
 
 }
 
 /**
- * An exception that is thrown when an action is prevented by the [CBFSecurityManager].
+ * An exception that is thrown when an action is prevented by the [CbfSecurityManager].
  */
-class CBFSecurityException internal constructor(type: KType, any: Any) : RuntimeException(
-    "Registration of $any for $type prevented by CBFSecurityManager"
+class CbfSecurityException internal constructor(type: KType, any: Any) : RuntimeException(
+    "Registration of $any for $type prevented by CbfSecurityManager"
 )

cosmic-binary-format/src/main/kotlin/xyz/xenondevs/cbf/Compound.kt

@@ -15,6 +15,7 @@ import kotlin.concurrent.withLock
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubtypeOf
 import kotlin.reflect.full.isSupertypeOf
+import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
 
 /**
@@ -96,7 +97,7 @@ private class DirectCompoundEntry<T : Any> private constructor(
             return ProviderCompoundEntry(type, this.cachedValue as R, default)
         } else {
             assert(bin != null)
-            val value: R = CBF.read(type, bin!!)
+            val value: R = Cbf.read(type, bin!!)
                 ?: throw AssertionError("Serialized value is null, but $type was expected")
             return ProviderCompoundEntry(type, value, default)
         }
@@ -116,17 +117,20 @@ private class DirectCompoundEntry<T : Any> private constructor(
 
     @OptIn(UncheckedApi::class)
     override fun get(type: KType): T {
+        val type = type.withNullability(false)
+        
         if (this.type != null && this.cachedValue != null) {
             if (!type.isSupertypeOf(this.type!!))
                 throw IllegalArgumentException("$type (return type) is not a supertype of ${this.type} (entry type)")
             return this.cachedValue as T
         } else {
             assert(bin != null)
 
-            this.type = type
-            this.cachedValue = CBF.read(type, bin!!)
-                ?: throw AssertionError("Serialized value is null, but $type was expected")
-            this.bin = null
+            set(
+                type.withNullability(false),
+                Cbf.read(type, bin!!)
+                    ?: throw AssertionError("Serialized value is null, but $type was expected")
+            )
 
             return this.cachedValue!!
         }
@@ -135,7 +139,7 @@ private class DirectCompoundEntry<T : Any> private constructor(
     @OptIn(UncheckedApi::class)
     override fun serialize(): ByteArray? {
         if (type != null && cachedValue != null) {
-            return CBF.write(type!!, cachedValue)
+            return Cbf.write(type!!, cachedValue)
         } else {
             return bin
         }
@@ -156,7 +160,7 @@ private class DirectCompoundEntry<T : Any> private constructor(
                 } else {
                     // no type check possible
                     assert(bin != null)
-                    val value = CBF.read<T>(entry.type, bin!!)
+                    val value = Cbf.read<T>(entry.type, bin!!)
                         ?: throw AssertionError("Serialized value is null, but $type was expected")
                     entry.set(entry.type, value)
                 }
@@ -201,7 +205,7 @@ private class ProviderCompoundEntry<T>(
 
     @OptIn(UncheckedApi::class)
     override fun serialize(): ByteArray? {
-        return cachedValue?.let { CBF.write(type, it) }
+        return cachedValue?.let { Cbf.write(type, it) }
     }
 
     override fun transferTo(entry: CompoundEntry<T>) {
@@ -221,7 +225,7 @@ private class ProviderCompoundEntry<T>(
 }
 
 /**
- * A compound is a key-value storage intended for serialization via [CBF].
+ * A compound is a key-value storage intended for serialization via [Cbf].
  *
  * After deserialization, a [Compound] contains only binary data of values of unknown types
  * (and the keys under which they're stored), which is then lazily deserialized
@@ -264,7 +268,7 @@ class Compound private constructor(
         when (entry) {
             is DirectCompoundEntry<T> -> {
                 if (value != null) {
-                    entry.set(type, value)
+                    entry.set(type.withNullability(false), value)
                 } else {
                     entryMap -= key
                 }
@@ -273,7 +277,7 @@ class Compound private constructor(
             is ProviderCompoundEntry<T> -> entry.set(type, value)
             null -> {
                 if (value != null) {
-                    entryMap[key] = DirectCompoundEntry(type, value)
+                    entryMap[key] = DirectCompoundEntry(type.withNullability(false), value)
                 }
             }
         }
@@ -434,11 +438,11 @@ class Compound private constructor(
     }
 
     /**
-     * Creates a deep copy of this compound, copying all deserialized values using [CBF.copy].
+     * Creates a deep copy of this compound, copying all deserialized values using [Cbf.copy].
      */
     @OptIn(UncheckedApi::class)
     fun copy(): Compound = lock.withLock {
-        copy { type, obj -> CBF.copy(type, obj) }
+        copy { type, obj -> Cbf.copy(type, obj)!! }
     }
 
     /**