Experimental | 优化 & 物品生成重构 & 重命名

TheFloodDragon · Aug 17, 2024 · 9853755 · 9853755
1 parent 50c0372
commit 9853755
Show file tree

Hide file tree

Showing 33 changed files with 420 additions and 425 deletions.
diff --git a/project/module-core/src/main/java/cn/fd/ratziel/function/ArgumentContext.java b/project/module-core/src/main/java/cn/fd/ratziel/function/ArgumentContext.java
@@ -1,5 +1,6 @@
 package cn.fd.ratziel.function;
 
+import cn.fd.ratziel.function.exception.ArgumentNotFoundException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -16,11 +17,11 @@ public interface ArgumentContext {
     /**
      * 弹出第一个指定类型的参数
      *
-     * @throws NullPointerException 当无法找到指定类型的参数时抛出
+     * @throws ArgumentNotFoundException 当无法找到指定类型的参数时抛出
      */
-    default <@NotNull T> @NotNull T pop(@NotNull Class<T> type) throws NullPointerException {
+    default <@NotNull T> @NotNull T pop(@NotNull Class<T> type) throws ArgumentNotFoundException {
         T result = popOrNull(type);
-        if (result == null) throw new NullPointerException("Cannot find argument: " + type.getName() + " !");
+        if (result == null) throw new ArgumentNotFoundException(type);
         return result;
     }
 

diff --git a/...module-core/src/main/java/cn/fd/ratziel/function/exception/ArgumentNotFoundException.java b/...module-core/src/main/java/cn/fd/ratziel/function/exception/ArgumentNotFoundException.java
@@ -0,0 +1,15 @@
+package cn.fd.ratziel.function.exception;
+
+/**
+ * ArgumentNotFoundException
+ *
+ * @author TheFloodDragon
+ * @since 2024/8/16 18:28
+ */
+public final class ArgumentNotFoundException extends Exception {
+
+    public ArgumentNotFoundException(Class<?> type) {
+        super("Cannot found the argument: " + type.getName() + " !");
+    }
+
+}
diff --git a/project/module-core/src/main/kotlin/cn/fd/ratziel/core/Identifier.kt b/project/module-core/src/main/kotlin/cn/fd/ratziel/core/Identifier.kt
@@ -8,19 +8,13 @@ package cn.fd.ratziel.core
  */
 interface Identifier {
 
-
-    /**
-     * 判断此标识符是否与另一个对象相同
-     */
-    override fun equals(other: Any?): Boolean
-
     /**
-     * 获取标识符的字符串形式
+     * 获取标识符的字符串内容
      */
-    override fun toString(): String
+    val content: String
 
     /**
-     * 此标识符的Hash码
+     * 此标识符的 [hashCode]
      */
     override fun hashCode(): Int
 

diff --git a/project/module-core/src/main/kotlin/cn/fd/ratziel/core/IdentifierImpl.kt b/project/module-core/src/main/kotlin/cn/fd/ratziel/core/IdentifierImpl.kt
@@ -8,16 +8,13 @@ import java.util.*
  * @author TheFloodDragon
  * @since 2024/6/24 13:47
  */
-open class IdentifierImpl(val unique: String) : Identifier {
+@JvmInline
+value class IdentifierImpl(override val content: String) : Identifier {
 
     constructor(uuid: UUID) : this(uuid.toString())
 
     constructor() : this(UUID.randomUUID())
 
-    override fun equals(other: Any?): Boolean = unique == other
-
-    override fun toString(): String = unique
-
-    override fun hashCode(): Int = unique.hashCode()
+    override fun toString() = "Identifier(unique=$content)"
 
 }
diff --git a/project/module-core/src/main/kotlin/cn/fd/ratziel/core/element/ElementIdentifier.kt b/project/module-core/src/main/kotlin/cn/fd/ratziel/core/element/ElementIdentifier.kt
@@ -24,6 +24,8 @@ open class ElementIdentifier(
     open val file: File?,
 ) : Identifier {
 
+    override val content get() = this.name
+
     override fun toString() = this::class.java.simpleName + '{' + "name=" + name + ";" + "type=" + type + ";" + "path=" + file?.path + '}'
 
     override fun equals(other: Any?) = other is ElementIdentifier && this.name == other.name && this.type == other.type && this.file == other.file

diff --git a/project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/ItemElement.kt b/project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/ItemElement.kt
@@ -4,11 +4,13 @@ import cn.fd.ratziel.common.element.registry.NewElement
 import cn.fd.ratziel.common.event.WorkspaceLoadEvent
 import cn.fd.ratziel.core.element.Element
 import cn.fd.ratziel.core.element.api.ElementHandler
-import cn.fd.ratziel.module.item.impl.builder.DefaultItemGenerator
+import cn.fd.ratziel.module.item.impl.builder.DefaultGenerator
+import cn.fd.ratziel.module.item.impl.builder.DefaultSerializer
+import cn.fd.ratziel.module.item.impl.component.*
 import cn.fd.ratziel.module.item.nms.RefItemStack
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.cancel
+import kotlinx.coroutines.asCoroutineDispatcher
 import taboolib.common.platform.event.SubscribeEvent
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
@@ -35,16 +37,23 @@ object ItemElement : ElementHandler {
     /**
      * 协程作用域
      */
-    val buildScope = CoroutineScope(Dispatchers.Default)
+    val scope = CoroutineScope(CoroutineName("ItemHandler") + executor.asCoroutineDispatcher())
 
     init {
-        // 注册默认的东西
-        ItemRegistry.registerDefault()
+        // 注册默认序列化器
+        ItemRegistry.register(DefaultSerializer)
+        // 注册默认转换器
+        ItemRegistry.register(ItemDisplay::class.java, ItemDisplay)
+        ItemRegistry.register(ItemDurability::class.java, ItemDurability)
+        ItemRegistry.register(ItemSundry::class.java, ItemSundry)
+        ItemRegistry.register(ItemMetadata::class.java, ItemMetadata)
+        ItemRegistry.register(ItemCharacteristic::class.java, ItemCharacteristic)
+        // 注册自定义物品解析器 (默认解析器无需注册, 保持在最后直接使用)
     }
 
     override fun handle(element: Element) {
 
-        val generator = DefaultItemGenerator(element)
+        val generator = DefaultGenerator(element)
 
         val item = generator.build().get()
 
@@ -61,8 +70,6 @@ object ItemElement : ElementHandler {
 
     @SubscribeEvent
     fun onLoadStart(event: WorkspaceLoadEvent.Start) {
-        // 清除协程任务
-        buildScope.cancel()
         // 清除注册的物品
         ItemManager.registry.clear()
     }

diff --git a/project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/ItemRegistry.kt b/project/module-item/src/main/kotlin/cn/fd/ratziel/module/item/ItemRegistry.kt
@@ -9,9 +9,6 @@ import cn.fd.ratziel.module.item.api.builder.ItemTransformer
 import cn.fd.ratziel.module.item.api.registry.ComponentRegistry
 import cn.fd.ratziel.module.item.api.registry.ResolverRegistry
 import cn.fd.ratziel.module.item.api.registry.SerializerRegistry
-import cn.fd.ratziel.module.item.impl.builder.CommonItemResolver
-import cn.fd.ratziel.module.item.impl.builder.CommonItemSerializer
-import cn.fd.ratziel.module.item.impl.component.*
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
 
@@ -24,114 +21,111 @@ import java.util.concurrent.CopyOnWriteArrayList
 object ItemRegistry {
 
     /**
-     * 注册默认的东西
+     * 注册组件
      */
-    internal fun registerDefault() {
-        // 注册默认序列化器
-        Serializer.register(CommonItemSerializer)
-        // 注册默认转换器
-        Component.register(ItemDisplay::class.java, ItemDisplay)
-        Component.register(ItemDurability::class.java, ItemDurability)
-        Component.register(ItemSundry::class.java, ItemSundry)
-        Component.register(ItemMetadata::class.java, ItemMetadata)
-        Component.register(ItemCharacteristic::class.java, ItemCharacteristic)
-        // 注册默认物品解析器
-//        Resolver.register(BasicItemResolver)
-        Resolver.register(CommonItemResolver)
-    }
+    fun <T> register(type: Class<T>, transformer: ItemTransformer<out T>) = Component.register(type, transformer)
+
+    /**
+     * 注册解析器
+     */
+    fun register(resolver: ItemResolver) = Resolver.register(resolver)
+
+    /**
+     * 注册序列化器
+     */
+    fun register(serializer: ItemSerializer<*>) = Serializer.register(serializer)
 
     object Component : ComponentRegistry {
 
         /**
          * 物品组件注册表
          */
-        internal val registry: MutableMap<Class<*>, Priority<ItemTransformer<*>>> = ConcurrentHashMap()
+        internal val registry: MutableMap<Class<*>, ItemTransformer<*>> = ConcurrentHashMap()
 
-        override fun <T> register(type: Class<T>, transformer: ItemTransformer<out T>, priority: Byte) {
-            registry[type] = Priority(priority, transformer)
+        override fun <T> register(type: Class<T>, transformer: ItemTransformer<out T>) {
+            registry[type] = transformer
         }
 
         override fun unregister(type: Class<*>) {
             registry.remove(type)
         }
 
-        override fun <T> getPriority(type: Class<T>): Priority<ItemTransformer<out T>>? = uncheck(registry[type])
+        override fun <T> get(type: Class<T>): ItemTransformer<out T>? = uncheck(registry[type])
 
-        override fun isRegistered(type: Class<*>) = registry.containsKey(type)
+        @Suppress("UNCHECKED_CAST")
+        fun getUnsafe(type: Class<*>): ItemTransformer<in Any>? = registry[type] as? ItemTransformer<in Any>
 
-        override fun getRegistry(): Map<Class<*>, ItemTransformer<*>> = buildMap {
-            getRegistryPriority().forEach { (k, p) -> put(k, p.value) }
-        }
+        override fun isRegistered(type: Class<*>) = registry.containsKey(type)
 
-        override fun getRegistryPriority(): Map<Class<*>, Priority<ItemTransformer<*>>> = registry
+        override fun getRegistry() = registry
 
     }
 
-    object Serializer : SerializerRegistry {
+    object Resolver : ResolverRegistry {
 
         /**
          * 物品序列化器注册表
          */
-        internal val registry: MutableList<ItemSerializer<*>> = CopyOnWriteArrayList()
+        internal val registry: MutableList<Priority<ItemResolver>> = CopyOnWriteArrayList()
 
-        override fun register(serializer: ItemSerializer<*>) {
-            registry.add(serializer)
+        override fun register(resolver: ItemResolver, priority: Byte) {
+            registry.add(Priority(priority, resolver))
         }
 
-        override fun unregister(type: Class<out ItemSerializer<*>>) {
+        override fun unregister(type: Class<out ItemResolver>) {
             for (element in registry) {
-                if (element::class.java == type) registry.remove(element)
+                if (element.value::class.java == type) registry.remove(element)
             }
         }
 
-        override fun unregister(serializer: ItemSerializer<*>) {
-            registry.remove(serializer)
+        override fun unregister(resolver: ItemResolver) {
+            for (element in registry) {
+                if (element.value == resolver) registry.remove(element)
+            }
         }
 
-        override fun <T : ItemSerializer<*>> get(type: Class<T>): T? = uncheck(registry.find { it::class.java == type })
+        override fun <T : ItemResolver> getWithPriority(type: Class<T>): Priority<T>? = uncheck(registry.find { it::class.java == type })
 
-        override fun isRegistered(type: Class<out ItemSerializer<*>>) = registry.find { it::class.java == type } != null
+        override fun isRegistered(type: Class<out ItemResolver>) = registry.find { it.value::class.java == type } != null
 
-        override fun isRegistered(serializer: ItemSerializer<*>) = registry.contains(serializer)
+        override fun isRegistered(resolver: ItemResolver) = registry.find { it.value == resolver } != null
 
-        override fun getSerializers(): List<ItemSerializer<*>> = registry
+        override fun getResolvers() = registry.map { it.value }
+
+        override fun getResolversWithPriority(): Collection<Priority<ItemResolver>> = registry
+
+        fun getResolversSorted(): List<ItemResolver> = registry.sortPriority()
 
     }
 
-    object Resolver : ResolverRegistry {
+    object Serializer : SerializerRegistry {
 
         /**
          * 物品序列化器注册表
          */
-        internal val registry: MutableList<Priority<ItemResolver>> = CopyOnWriteArrayList()
+        internal val registry: MutableList<ItemSerializer<*>> = CopyOnWriteArrayList()
 
-        override fun register(resolver: ItemResolver, priority: Byte) {
-            registry.add(Priority(priority, resolver))
+        override fun register(serializer: ItemSerializer<*>) {
+            registry.add(serializer)
         }
 
-        override fun unregister(type: Class<out ItemResolver>) {
+        override fun unregister(type: Class<out ItemSerializer<*>>) {
             for (element in registry) {
-                if (element.value::class.java == type) registry.remove(element)
+                if (element::class.java == type) registry.remove(element)
             }
         }
 
-        override fun unregister(resolver: ItemResolver) {
-            for (element in registry) {
-                if (element.value == resolver) registry.remove(element)
-            }
+        override fun unregister(serializer: ItemSerializer<*>) {
+            registry.remove(serializer)
         }
 
-        override fun <T : ItemResolver> getPriority(type: Class<T>): Priority<T>? = uncheck(registry.find { it::class.java == type })
-
-        override fun isRegistered(type: Class<out ItemResolver>) = registry.find { it.value::class.java == type } != null
-
-        override fun isRegistered(resolver: ItemResolver) = registry.find { it.value == resolver } != null
+        override fun <T : ItemSerializer<*>> get(type: Class<T>): T? = uncheck(registry.find { it::class.java == type })
 
-        override fun getResolvers() = registry.map { it.value }
+        override fun isRegistered(type: Class<out ItemSerializer<*>>) = registry.find { it::class.java == type } != null
 
-        override fun getResolversPriority(): Collection<Priority<ItemResolver>> = registry
+        override fun isRegistered(serializer: ItemSerializer<*>) = registry.contains(serializer)
 
-        fun getResolversSorted(): List<ItemResolver> = registry.sortPriority()
+        override fun getSerializers(): List<ItemSerializer<*>> = registry
 
     }
 

diff --git a/...t/module-item/src/main/kotlin/cn/fd/ratziel/module/item/api/builder/SectionTagResolver.kt b/...t/module-item/src/main/kotlin/cn/fd/ratziel/module/item/api/builder/SectionTagResolver.kt
@@ -8,7 +8,7 @@ import cn.fd.ratziel.module.item.api.ArgumentResolver
  * @author TheFloodDragon
  * @since 2024/8/13 14:44
  */
-interface SectionTagResolver :ArgumentResolver<Iterable<String>, String?>{
+interface SectionTagResolver : ArgumentResolver<List<String>, String?> {
 
     /**
      * 解析器名称

diff --git a/...module/item/api/event/ItemResolveEvent.kt → ...odule/item/api/event/ItemResolvedEvent.kt b/...module/item/api/event/ItemResolveEvent.kt → ...odule/item/api/event/ItemResolvedEvent.kt
@@ -1,28 +1,23 @@
 package cn.fd.ratziel.module.item.api.event
 
 import cn.fd.ratziel.core.Identifier
-import cn.fd.ratziel.function.ArgumentContext
 import kotlinx.serialization.json.JsonElement
 
 /**
- * ItemResolveEvent
+ * ItemResolvedEvent
  *
  * 构建物品中的所有解析阶段完成后触发
  *
  * @author TheFloodDragon
  * @since 2024/7/3 15:15
  */
-class ItemResolveEvent(
+class ItemResolvedEvent(
     /**
      * 物品标识符
      */
     identifier: Identifier,
     /**
-     * 解析出的最终结果
+     * 解析结果
      */
-    var result: JsonElement,
-    /**
-     * 上下文
-     */
-    val context: ArgumentContext
+    val result: JsonElement,
 ) : ItemEvent(identifier)