wrap the plugin-specific code to a dedicated item class

Author: HSGamer

all/pom.xml

@@ -18,11 +18,6 @@
             <artifactId>uni-item-api</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <dependency>
-            <groupId>io.github.projectunified</groupId>
-            <artifactId>uni-item-multi</artifactId>
-            <version>${project.version}</version>
-        </dependency>
         <dependency>
             <groupId>io.github.projectunified</groupId>
             <artifactId>uni-item-itembridge</artifactId>

all/src/main/java/io/github/projectunified/uniitem/all/AllItemProvider.java

@@ -1,5 +1,8 @@
 package io.github.projectunified.uniitem.all;
 
+import io.github.projectunified.uniitem.api.Item;
+import io.github.projectunified.uniitem.api.ItemKey;
+import io.github.projectunified.uniitem.api.ItemProvider;
 import io.github.projectunified.uniitem.craftengine.CraftEngineItemProvider;
 import io.github.projectunified.uniitem.customfishing.CustomFishingProvider;
 import io.github.projectunified.uniitem.eco.EcoItemProvider;
@@ -9,62 +12,98 @@
 import io.github.projectunified.uniitem.itemedit.ItemEditProvider;
 import io.github.projectunified.uniitem.itemsadder.ItemsAdderProvider;
 import io.github.projectunified.uniitem.mmoitems.MMOItemsProvider;
-import io.github.projectunified.uniitem.multi.MultiItemProvider;
 import io.github.projectunified.uniitem.mythicmobs.MythicItemProvider;
 import io.github.projectunified.uniitem.nexo.NexoProvider;
 import io.github.projectunified.uniitem.nova.NovaItemProvider;
 import io.github.projectunified.uniitem.oraxen.OraxenProvider;
 import io.github.projectunified.uniitem.slimefun.SlimefunProvider;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+public class AllItemProvider implements ItemProvider {
+    private final AtomicReference<List<ItemProvider>> providers = new AtomicReference<>();
+
+    private List<ItemProvider> constructProviders() {
+        List<ItemProvider> providers = new ArrayList<>();
 
-public class AllItemProvider extends MultiItemProvider {
-    public AllItemProvider() {
         // Dependent
         if (ItemEditProvider.isAvailable()) {
-            addProvider(new ItemEditProvider());
+            providers.add(new ItemEditProvider());
         }
         if (CraftEngineItemProvider.isAvailable()) {
-            addProvider(new CraftEngineItemProvider());
+            providers.add(new CraftEngineItemProvider());
         }
         if (CustomFishingProvider.isAvailable()) {
-            addProvider(new CustomFishingProvider());
+            providers.add(new CustomFishingProvider());
         }
         if (EcoItemProvider.isAvailable()) {
-            EcoItemProvider provider = new EcoItemProvider();
-            addProvider(provider, provider.type());
+            providers.add(new EcoItemProvider());
         }
         if (ExecutableItemsProvider.isAvailable()) {
-            addProvider(new ExecutableItemsProvider());
+            providers.add(new ExecutableItemsProvider());
         }
         if (MMOItemsProvider.isAvailable()) {
-            addProvider(new MMOItemsProvider());
+            providers.add(new MMOItemsProvider());
         }
         if (MythicItemProvider.isAvailable()) {
-            addProvider(new MythicItemProvider(), "mm");
+            providers.add(new MythicItemProvider());
         }
 
         // Base
         if (ItemsAdderProvider.isAvailable()) {
-            addProvider(new ItemsAdderProvider(), "ia");
+            providers.add(new ItemsAdderProvider());
         }
         if (OraxenProvider.isAvailable()) {
-            addProvider(new OraxenProvider(), "orx");
+            providers.add(new OraxenProvider());
         }
         if (NexoProvider.isAvailable()) {
-            addProvider(new NexoProvider());
+            providers.add(new NexoProvider());
         }
         if (HeadDatabaseProvider.isAvailable()) {
-            addProvider(new HeadDatabaseProvider(), "hdb", "headdb");
+            providers.add(new HeadDatabaseProvider());
         }
         if (NovaItemProvider.isAvailable()) {
-            addProvider(new NovaItemProvider());
+            providers.add(new NovaItemProvider());
         }
         if (SlimefunProvider.isAvailable()) {
-            addProvider(new SlimefunProvider(), "sf");
+            providers.add(new SlimefunProvider());
         }
 
         // Bridge
         if (ItemBridgeProvider.isAvailable()) {
-            addProvider(new ItemBridgeProvider(), "item-bridge");
+            providers.add(new ItemBridgeProvider());
+        }
+
+        return providers;
+    }
+
+    private List<ItemProvider> getProviders() {
+        List<ItemProvider> providerList = providers.get();
+        if (providerList == null) {
+            providerList = constructProviders();
+            providers.set(providerList);
         }
+        return providerList;
+    }
+
+    @Override
+    public List<String> availableTypes() {
+        return getProviders().parallelStream().map(ItemProvider::availableTypes).flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    @Override
+    public @NotNull Item wrap(@NotNull ItemStack item) {
+        return getProviders().stream().map(provider -> provider.wrap(item)).filter(Item::isValid).findFirst().orElse(Item.INVALID);
+    }
+
+    @Override
+    public @NotNull Item wrap(@NotNull ItemKey key) {
+        return getProviders().stream().map(provider -> provider.wrap(key)).filter(Item::isValid).findFirst().orElse(Item.INVALID);
     }
 }

api/src/main/java/io/github/projectunified/uniitem/api/Item.java

@@ -0,0 +1,49 @@
+package io.github.projectunified.uniitem.api;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface Item {
+    Item INVALID = new Item() {
+        @Override
+        public boolean isValid() {
+            return false;
+        }
+
+        @Override
+        public @Nullable ItemKey key() {
+            return null;
+        }
+
+        @Override
+        public @Nullable ItemStack bukkitItem() {
+            return null;
+        }
+
+        @Override
+        public @Nullable ItemStack bukkitItem(@NotNull Player player) {
+            return null;
+        }
+
+        @Override
+        public boolean isSimilar(@NotNull ItemStack item) {
+            return false;
+        }
+    };
+
+    boolean isValid();
+
+    @Nullable ItemKey key();
+
+    @Nullable ItemStack bukkitItem();
+
+    @Nullable ItemStack bukkitItem(@NotNull Player player);
+
+    default @Nullable ItemStack tryBukkitItem(@Nullable Player player) {
+        return player == null ? bukkitItem() : bukkitItem(player);
+    }
+
+    boolean isSimilar(@NotNull ItemStack item);
+}

api/src/main/java/io/github/projectunified/uniitem/api/ItemKey.java

@@ -1,5 +1,6 @@
 package io.github.projectunified.uniitem.api;
 
+import java.util.Collection;
 import java.util.Locale;
 import java.util.Objects;
 
@@ -38,6 +39,17 @@ public String type() {
         return type;
     }
 
+    public boolean isType(String type) {
+        return this.type.equalsIgnoreCase(type);
+    }
+
+    public boolean isType(Collection<String> types) {
+        for (String type : types) {
+            if (isType(type)) return true;
+        }
+        return false;
+    }
+
     public String id() {
         return id;
     }

api/src/main/java/io/github/projectunified/uniitem/api/ItemProvider.java

@@ -5,29 +5,36 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Objects;
+import java.util.List;
 
 public interface ItemProvider {
-    boolean isValidKey(@NotNull ItemKey key);
+    List<String> availableTypes();
 
-    @Nullable ItemKey key(@NotNull ItemStack item);
+    @NotNull Item wrap(@NotNull ItemStack item);
 
-    @Nullable ItemStack item(@NotNull ItemKey key);
+    @NotNull Item wrap(@NotNull ItemKey key);
+
+    default boolean isValidKey(@NotNull ItemKey key) {
+        return wrap(key).isValid();
+    }
+
+    default @Nullable ItemKey key(@NotNull ItemStack item) {
+        return wrap(item).key();
+    }
+
+    default @Nullable ItemStack item(@NotNull ItemKey key) {
+        return wrap(key).bukkitItem();
+    }
 
     default @Nullable ItemStack item(@NotNull ItemKey key, @NotNull Player player) {
-        return item(key);
+        return wrap(key).bukkitItem(player);
     }
 
     default @Nullable ItemStack tryItem(@NotNull ItemKey key, @Nullable Player player) {
-        return player == null ? item(key) : item(key, player);
+        return wrap(key).tryBukkitItem(player);
     }
 
     default boolean isSimilar(@NotNull ItemStack item, @NotNull ItemKey key) {
-        if (!isValidKey(key)) return false;
-
-        ItemKey itemKey = key(item);
-        if (itemKey == null) return false;
-
-        return Objects.equals(itemKey, key);
+        return wrap(key).isSimilar(item);
     }
 }

api/src/main/java/io/github/projectunified/uniitem/api/SimpleItemProvider.java

@@ -0,0 +1,60 @@
+package io.github.projectunified.uniitem.craftengine;
+
+import io.github.projectunified.uniitem.api.Item;
+import io.github.projectunified.uniitem.api.ItemKey;
+import net.momirealms.craftengine.bukkit.api.CraftEngineItems;
+import net.momirealms.craftengine.core.item.CustomItem;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.util.Key;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+class CraftEngineItem implements Item {
+    private final @Nullable CustomItem<ItemStack> customItem;
+
+    CraftEngineItem(String id) {
+        Key key = Key.of(id);
+        this.customItem = CraftEngineItems.byId(key);
+    }
+
+    CraftEngineItem(ItemStack itemStack) {
+        Key key = CraftEngineItems.getCustomItemId(itemStack);
+        this.customItem = key == null ? null : CraftEngineItems.byId(key);
+    }
+
+    @Override
+    public boolean isValid() {
+        return customItem != null;
+    }
+
+    @Override
+    public @Nullable ItemKey key() {
+        if (customItem == null) return null;
+        return new ItemKey(CraftEngineItemProvider.TYPE, customItem.id().asString());
+    }
+
+    @Override
+    public @Nullable ItemStack bukkitItem() {
+        if (customItem == null) return null;
+        return customItem.buildItemStack();
+    }
+
+    @Override
+    public @Nullable ItemStack bukkitItem(@NotNull Player player) {
+        if (customItem == null) return null;
+        net.momirealms.craftengine.core.entity.player.Player customPlayer = net.momirealms.craftengine.bukkit.api.BukkitAdaptors.adapt(player);
+        ItemBuildContext context = ItemBuildContext.of(customPlayer);
+        return customItem.buildItemStack(context);
+    }
+
+    @Override
+    public boolean isSimilar(@NotNull ItemStack item) {
+        if (customItem == null) return false;
+        Key key = CraftEngineItems.getCustomItemId(item);
+        return Objects.equals(key, customItem.id());
+    }
+}