Experimental | Add of function for NBTs

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTAdapter.kt

@@ -10,43 +10,49 @@ import cn.fd.ratziel.core.exception.UnsupportedTypeException
  */
 object NBTAdapter {
 
+    @JvmStatic
     fun adapt(target: Any): NBTData = when {
         target is NBTData -> target
         isNmsNBT(target) -> NmsAdapter.adapt(target)
         else -> BasicAdapter.adapt(target)
     } ?: throw UnsupportedTypeException(target)
 
+    @JvmStatic
     fun adaptNms(target: Any) = NmsAdapter.adapt(target)!!
 
+    @JvmStatic
     fun adaptList(target: Iterable<*>): NBTList = ArrayList<Any>().apply {
-        target.forEach { unsure -> unsure?.let { add(adapt(it).getData()) } }
-    }.let { NBTList(NBTList.new(it)) }
+        target.forEach { unsure -> unsure?.let { add(adapt(it).getRaw()) } }
+    }.let { NBTList.of(NBTList.new(it)) }
 
+    @JvmStatic
     fun adaptMap(target: Map<*, *>): NBTCompound = HashMap<String, Any>().apply {
-        target.forEach { (node, unsure) -> unsure?.let { put(node.toString(), adapt(it).getData()) } }
-    }.let { NBTCompound(NBTCompound.new(it)) }
+        target.forEach { (node, unsure) -> unsure?.let { put(node.toString(), adapt(it).getRaw()) } }
+    }.let { NBTCompound.of(NBTCompound.new(it)) }
 
     /**
      * 判断目标是否为 NmsNBT
      */
+    @JvmStatic
     fun isNmsNBT(target: Any) = NMSUtil.NtBase.nmsClass.isAssignableFrom(target::class.java)
 
     object NmsAdapter {
 
+        @JvmStatic
         fun adapt(target: Any) = target::class.java.let { c ->
             when {
-                NMSUtil.NtCompound.nmsClass.isAssignableFrom(c) -> NBTCompound(target)
-                NMSUtil.NtList.nmsClass.isAssignableFrom(c) -> NBTList(target)
-                NMSUtil.NtString.nmsClass.isAssignableFrom(c) -> NBTString(target)
-                NMSUtil.NtInt.nmsClass.isAssignableFrom(c) -> NBTInt(target)
-                NMSUtil.NtDouble.nmsClass.isAssignableFrom(c) -> NBTDouble(target)
-                NMSUtil.NtByte.nmsClass.isAssignableFrom(c) -> NBTByte(target)
-                NMSUtil.NtFloat.nmsClass.isAssignableFrom(c) -> NBTFloat(target)
-                NMSUtil.NtLong.nmsClass.isAssignableFrom(c) -> NBTLong(target)
-                NMSUtil.NtShort.nmsClass.isAssignableFrom(c) -> NBTShort(target)
-                NMSUtil.NtIntArray.nmsClass.isAssignableFrom(c) -> NBTIntArray(target)
-                NMSUtil.NtByteArray.nmsClass.isAssignableFrom(c) -> NBTByteArray(target)
-                NMSUtil.NtLongArray.nmsClass.isAssignableFrom(c) -> NBTLongArray(target)
+                NMSUtil.NtCompound.nmsClass.isAssignableFrom(c) -> NBTCompound.of(target)
+                NMSUtil.NtList.nmsClass.isAssignableFrom(c) -> NBTList.of(target)
+                NMSUtil.NtString.nmsClass.isAssignableFrom(c) -> NBTString.of(target)
+                NMSUtil.NtInt.nmsClass.isAssignableFrom(c) -> NBTInt.of(target)
+                NMSUtil.NtDouble.nmsClass.isAssignableFrom(c) -> NBTDouble.of(target)
+                NMSUtil.NtByte.nmsClass.isAssignableFrom(c) -> NBTByte.of(target)
+                NMSUtil.NtFloat.nmsClass.isAssignableFrom(c) -> NBTFloat.of(target)
+                NMSUtil.NtLong.nmsClass.isAssignableFrom(c) -> NBTLong.of(target)
+                NMSUtil.NtShort.nmsClass.isAssignableFrom(c) -> NBTShort.of(target)
+                NMSUtil.NtIntArray.nmsClass.isAssignableFrom(c) -> NBTIntArray.of(target)
+                NMSUtil.NtByteArray.nmsClass.isAssignableFrom(c) -> NBTByteArray.of(target)
+                NMSUtil.NtLongArray.nmsClass.isAssignableFrom(c) -> NBTLongArray.of(target)
                 else -> null
             }
         }
@@ -55,19 +61,20 @@ object NBTAdapter {
 
     object BasicAdapter {
 
+        @JvmStatic
         fun adapt(target: Any): NBTData? = when (target) {
             // 基本类型转换
-            is String -> NBTString(NBTString.new(target))
-            is Int -> NBTInt(NBTInt.new(target))
-            is Double -> NBTDouble(NBTDouble.new(target))
-            is Boolean -> NBTByte(NBTByte.new(target))
-            is Byte -> NBTByte(NBTByte.new(target))
-            is Float -> NBTFloat(NBTFloat.new(target))
-            is Long -> NBTLong(NBTLong.new(target))
-            is Short -> NBTShort(NBTShort.new(target))
-            is IntArray -> NBTIntArray(NBTIntArray.new(target))
-            is ByteArray -> NBTByteArray(NBTByteArray.new(target))
-            is LongArray -> NBTLongArray(NBTLongArray.new(target))
+            is String -> NBTString(target)
+            is Int -> NBTInt(target)
+            is Double -> NBTDouble(target)
+            is Boolean -> NBTByte(target)
+            is Byte -> NBTByte(target)
+            is Float -> NBTFloat(target)
+            is Long -> NBTLong(target)
+            is Short -> NBTShort(target)
+            is IntArray -> NBTIntArray(target)
+            is ByteArray -> NBTByteArray(target)
+            is LongArray -> NBTLongArray(target)
             is Iterable<*> -> adaptList(target)
             is Array<*> -> adaptList(listOf(target))
             is Map<*, *> -> adaptMap(target)

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTByte.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTByte
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:20
  */
-class NBTByte(rawData: Any) : NBTData(rawData, NBTType.BYTE) {
+class NBTByte  private constructor(rawData: Any)  : NBTData(rawData, NBTType.BYTE) {
 
     constructor(value: Boolean) : this(new(value))
 
@@ -25,6 +27,9 @@ class NBTByte(rawData: Any) : NBTData(rawData, NBTType.BYTE) {
         @JvmStatic
         fun new(value: Byte) = NMSUtil.NtByte.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtByte.isOwnClass(raw::class.java)) NBTByte(raw) else throw UnsupportedTypeException(raw)
+
         @JvmStatic
         fun adapt(from: Byte): Boolean = adaptOrNull(from) ?: false
 

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTByteArray.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTByteArray
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:21
  */
-class NBTByteArray(rawData: Any) : NBTData(rawData, NBTType.BYTE_ARRAY) {
+class NBTByteArray private constructor(rawData: Any) : NBTData(rawData, NBTType.BYTE_ARRAY) {
 
     constructor(value: ByteArray) : this(new(value))
 
@@ -17,6 +19,9 @@ class NBTByteArray(rawData: Any) : NBTData(rawData, NBTType.BYTE_ARRAY) {
         @JvmStatic
         fun new(value: ByteArray) = NMSUtil.NtByteArray.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtByteArray.isOwnClass(raw::class.java)) NBTByteArray(raw) else throw UnsupportedTypeException(raw)
+
     }
 
 }

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTCompound.kt

@@ -1,5 +1,6 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
 import cn.fd.ratziel.function.util.uncheck
 
 /**
@@ -8,18 +9,22 @@ import cn.fd.ratziel.function.util.uncheck
  * @author TheFloodDragon
  * @since 2024/3/15 19:28
  */
-open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), MutableMap<String, NBTData> {
+open class NBTCompound private constructor(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), MutableMap<String, NBTData> {
 
     constructor() : this(new())
 
-    constructor(map: Map<*, *>) : this(NBTAdapter.adaptMap(map).getData())
+    constructor(map: Map<*, *>) : this(NBTAdapter.adaptMap(map).getRaw())
 
     /**
      * [java.util.Map] is the same as [MutableMap] in [kotlin.collections]
      * Because [MutableMap] will be compiled to [java.util.Map]
+     * And this is final, so it's not getter
      */
-    internal val sourceMap: MutableMap<String, Any> get() = uncheck(NMSUtil.NtCompound.sourceField.get(data)!!)
+    internal val sourceMap: MutableMap<String, Any> = uncheck(NMSUtil.NtCompound.sourceField.get(data)!!)
 
+    /**
+     * 内容
+     */
     override val content: Map<String, NBTData> get() = buildMap { sourceMap.forEach { put(it.key, NBTAdapter.adaptNms(it.value)) } }
 
     /**
@@ -33,7 +38,7 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
      * @param key 节点
      * @param value NBT数据
      */
-    override fun put(key: String, value: NBTData) = sourceMap.put(key, value.getData())?.let { NBTAdapter.adaptNms(it) }
+    override fun put(key: String, value: NBTData) = sourceMap.put(key, value.getRaw())?.let { NBTAdapter.adaptNms(it) }
 
     /**
      * 删除数据
@@ -60,7 +65,7 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
                 NMSUtil.NtCompound.isOwnClass(targetValue::class.java) -> ownValue
                     ?.takeIf { NMSUtil.NtCompound.isOwnClass(it::class.java) } // 若自身为 Compound 类型
                     ?.let { NBTCompound(it).merge(NBTCompound(targetValue), replace) }// 同类型合并
-                    ?.getData()
+                    ?.getRaw()
                 // 目标值为基础类型, 或者 List 类型
                 else -> null
             } ?: if (ownValue == null || replace) targetValue else return@forEach
@@ -90,6 +95,9 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
         @JvmStatic
         fun new(map: Map<String, Any>) = NMSUtil.NtCompound.constructor.instance(map)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtCompound.isOwnClass(raw::class.java)) NBTCompound(raw) else throw UnsupportedTypeException(raw)
+
     }
 
     operator fun set(node: String, value: NBTData?) = value?.let { put(node, it) }
@@ -104,7 +112,7 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
 
     override fun isEmpty() = sourceMap.isEmpty()
 
-    override fun containsValue(value: NBTData) = sourceMap.containsValue(value.getData())
+    override fun containsValue(value: NBTData) = sourceMap.containsValue(value.getRaw())
 
     override fun containsKey(key: String) = sourceMap.containsKey(key)
 
@@ -114,8 +122,8 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
             override fun add(element: MutableMap.MutableEntry<String, NBTData>) =
                 sourceMap.entries.add(object : MutableMap.MutableEntry<String, Any> {
                     override val key get() = element.key
-                    override val value get() = element.value.getData()
-                    override fun setValue(newValue: Any) = element.setValue(NBTAdapter.adaptNms(newValue)).getData()
+                    override val value get() = element.value.getRaw()
+                    override fun setValue(newValue: Any) = element.setValue(NBTAdapter.adaptNms(newValue)).getRaw()
                 })
 
             override fun iterator() = sourceMap.entries.iterator().let { source ->
@@ -126,7 +134,7 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
                         object : MutableMap.MutableEntry<String, NBTData> {
                             override val key get() = it.key
                             override val value get() = NBTAdapter.adaptNms(it.value)
-                            override fun setValue(newValue: NBTData) = NBTAdapter.adaptNms(it.setValue(newValue.getData()))
+                            override fun setValue(newValue: NBTData) = NBTAdapter.adaptNms(it.setValue(newValue.getRaw()))
                         }
                     }
                 }
@@ -136,7 +144,7 @@ open class NBTCompound(rawData: Any) : NBTData(rawData, NBTType.COMPOUND), Mutab
 
     override val values: MutableCollection<NBTData> by lazy {
         object : AbstractMutableCollection<NBTData>() {
-            override fun add(element: NBTData) = sourceMap.values.add(element.getData())
+            override fun add(element: NBTData) = sourceMap.values.add(element.getRaw())
             override val size get() = sourceMap.values.size
             override fun iterator() = sourceMap.values.iterator().let {
                 object : MutableIterator<NBTData> {

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTData.kt

@@ -1,7 +1,5 @@
 package cn.fd.ratziel.module.item.nbt
 
-import cn.fd.ratziel.core.exception.UnsupportedTypeException
-
 /**
  * NBTData - NBT数据
  *
@@ -16,14 +14,9 @@ abstract class NBTData(
     /**
      * NBT数据类型
      */
-    val type: NBTType
+    @JvmField val type: NBTType
 ) {
 
-    init {
-        // 数据检验
-        if (!NMSUtil.inferUtil(type).isOwnClass(data::class.java)) throw UnsupportedTypeException(data)
-    }
-
     /**
      * 数据内容
      */
@@ -32,9 +25,9 @@ abstract class NBTData(
     /**
      * 获取原始数据
      */
-    open fun getData() = data
+    open fun getRaw() = data
 
-    override fun equals(other: Any?) = (if (other is NBTData) other.getData() else other) == data
+    override fun equals(other: Any?) = (if (other is NBTData) other.getRaw() else other) == data
 
     override fun toString() = data.toString()
 

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTDouble.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTDouble
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:18
  */
-class NBTDouble(rawData: Any) : NBTData(rawData, NBTType.DOUBLE) {
+class NBTDouble private constructor(rawData: Any) : NBTData(rawData, NBTType.DOUBLE) {
 
     constructor(value: Double) : this(new(value))
 
@@ -17,6 +19,9 @@ class NBTDouble(rawData: Any) : NBTData(rawData, NBTType.DOUBLE) {
         @JvmStatic
         fun new(value: Double) = NMSUtil.NtDouble.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtDouble.isOwnClass(raw::class.java)) NBTDouble(raw) else throw UnsupportedTypeException(raw)
+
     }
 
 }

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTFloat.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTFloat
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:23
  */
-class NBTFloat(rawData: Any) : NBTData(rawData, NBTType.FLOAT) {
+class NBTFloat private constructor(rawData: Any) : NBTData(rawData, NBTType.FLOAT) {
 
     constructor(value: Float) : this(new(value))
 
@@ -17,6 +19,9 @@ class NBTFloat(rawData: Any) : NBTData(rawData, NBTType.FLOAT) {
         @JvmStatic
         fun new(value: Float) = NMSUtil.NtFloat.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtFloat.isOwnClass(raw::class.java)) NBTFloat(raw) else throw UnsupportedTypeException(raw)
+
     }
 
 }

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTInt.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTInt
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:14
  */
-class NBTInt(rawData: Any) : NBTData(rawData, NBTType.INT) {
+class NBTInt private constructor(rawData: Any) : NBTData(rawData, NBTType.INT) {
 
     constructor(value: Int) : this(new(value))
 
@@ -17,6 +19,9 @@ class NBTInt(rawData: Any) : NBTData(rawData, NBTType.INT) {
         @JvmStatic
         fun new(value: Int) = NMSUtil.NtInt.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtInt.isOwnClass(raw::class.java)) NBTInt(raw) else throw UnsupportedTypeException(raw)
+
     }
 
 }

project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/nbt/NBTIntArray.kt

@@ -1,12 +1,14 @@
 package cn.fd.ratziel.module.item.nbt
 
+import cn.fd.ratziel.core.exception.UnsupportedTypeException
+
 /**
  * NBTIntArray
  *
  * @author TheFloodDragon
  * @since 2024/3/15 21:22
  */
-class NBTIntArray(rawData: Any) : NBTData(rawData, NBTType.INT_ARRAY) {
+class NBTIntArray private constructor(rawData: Any) : NBTData(rawData, NBTType.INT_ARRAY) {
 
     constructor(value: IntArray) : this(new(value))
 
@@ -17,6 +19,9 @@ class NBTIntArray(rawData: Any) : NBTData(rawData, NBTType.INT_ARRAY) {
         @JvmStatic
         fun new(value: IntArray) = NMSUtil.NtIntArray.constructor.instance(value)!!
 
+        @JvmStatic
+        fun of(raw: Any) = if (NMSUtil.NtIntArray.isOwnClass(raw::class.java)) NBTIntArray(raw) else throw UnsupportedTypeException(raw)
+
     }
 
 }