New StackReference System to replace old APIReferences

buildSrc/src/main/kotlin/com.wolfyscript.wolfyutils.spigot.java-conventions.gradle.kts

@@ -37,7 +37,7 @@ java {
 }
 
 group = "com.wolfyscript.wolfyutils.spigot"
-version = "4.16.14.1"
+version = "4.16.15-beta.2"
 val apiVersion = "4.16.1-SNAPSHOT"
 
 dependencies {

core/src/main/java/com/wolfyscript/utilities/bukkit/registry/RegistryStackIdentifierParsers.java

@@ -0,0 +1,66 @@
+package com.wolfyscript.utilities.bukkit.registry;
+
+import com.google.common.base.Preconditions;
+import com.wolfyscript.utilities.bukkit.world.items.reference.BukkitStackIdentifier;
+import com.wolfyscript.utilities.bukkit.world.items.reference.StackIdentifier;
+import com.wolfyscript.utilities.bukkit.world.items.reference.StackIdentifierParser;
+import com.wolfyscript.utilities.bukkit.world.items.reference.StackReference;
+import me.wolfyscript.utilities.registry.Registries;
+import me.wolfyscript.utilities.registry.RegistrySimple;
+import me.wolfyscript.utilities.util.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+public class RegistryStackIdentifierParsers extends RegistrySimple<StackIdentifierParser<?>> {
+
+    private List<StackIdentifierParser<?>> priorityIndexedParsers = List.of();
+    private final Registries registries;
+
+    public RegistryStackIdentifierParsers(Registries registries) {
+        super(new NamespacedKey(registries.getCore(), "stack_identifier/parsers"), registries, (Class<StackIdentifierParser<?>>)(Object) StackIdentifierParser.class);
+        this.registries = registries;
+    }
+
+    @Override
+    public void register(NamespacedKey namespacedKey, StackIdentifierParser<?> value) {
+        if (value != null) {
+            Preconditions.checkState(!this.map.containsKey(namespacedKey), "namespaced key '%s' already has an associated value!", namespacedKey);
+            map.put(namespacedKey, value);
+            reIndexParsers();
+        }
+    }
+
+    public List<StackIdentifierParser<?>> sortedParsers() {
+        return priorityIndexedParsers;
+    }
+
+    public StackIdentifier parseIdentifier(ItemStack stack) {
+        for (StackIdentifierParser<?> parser : sortedParsers()) {
+            Optional<? extends StackIdentifier> identifierOptional = parser.from(stack);
+            if (identifierOptional.isPresent()) return identifierOptional.get();
+        }
+        return new BukkitStackIdentifier(stack);
+    }
+
+    public List<StackIdentifierParser<?>> matchingParsers(ItemStack stack) {
+        return sortedParsers().stream().sorted().filter(stackIdentifierParser -> stackIdentifierParser.from(stack).isPresent()).toList();
+    }
+
+    /**
+     *
+     *
+     * @param stack
+     * @return
+     */
+    public StackReference parseFrom(ItemStack stack) {
+        return new StackReference(registries.getCore(), parseIdentifier(stack), 1, 1, stack);
+    }
+
+    private void reIndexParsers() {
+        priorityIndexedParsers = map.values().stream().sorted(Comparator.naturalOrder()).filter(Objects::nonNull).toList();
+    }
+}

core/src/main/java/com/wolfyscript/utilities/bukkit/world/items/reference/BukkitStackIdentifier.java

@@ -0,0 +1,68 @@
+package com.wolfyscript.utilities.bukkit.world.items.reference;
+
+import me.wolfyscript.utilities.util.NamespacedKey;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Optional;
+
+public class BukkitStackIdentifier implements StackIdentifier {
+
+    public static final NamespacedKey ID = NamespacedKey.wolfyutilties("bukkit");
+
+    private final ItemStack stack;
+
+    public BukkitStackIdentifier(ItemStack stack) {
+        this.stack = stack;
+    }
+
+    @Override
+    public ItemStack stack(ItemCreateContext context) {
+        ItemStack cloned = stack.clone();
+        cloned.setAmount(context.amount());
+        return cloned;
+    }
+
+    @Override
+    public boolean matches(ItemStack other, int count, boolean exact, boolean ignoreAmount) {
+        if (other.getType() != stack.getType()) return false;
+        if (!ignoreAmount && other.getAmount() < stack.getAmount() * count) return false;
+        if (!stack.hasItemMeta() && !exact) return false;
+        return stack.isSimilar(other);
+    }
+
+    @Override
+    public NamespacedKey getNamespacedKey() {
+        return ID;
+    }
+
+    public static class Parser implements StackIdentifierParser<BukkitStackIdentifier> {
+
+        @Override
+        public int priority() {
+            return -2048;
+        }
+
+        @Override
+        public Optional<BukkitStackIdentifier> from(ItemStack itemStack) {
+            return Optional.of(new BukkitStackIdentifier(itemStack.clone()));
+        }
+
+        @Override
+        public NamespacedKey getNamespacedKey() {
+            return ID;
+        }
+
+        @Override
+        public DisplayConfiguration displayConfig() {
+            return new DisplayConfiguration.SimpleDisplayConfig(
+                    Component.text("Bukkit").color(NamedTextColor.WHITE).decorate(TextDecoration.BOLD),
+                    new DisplayConfiguration.MaterialIconSettings(Material.LAVA_BUCKET)
+            );
+        }
+    }
+
+}

core/src/main/java/com/wolfyscript/utilities/bukkit/world/items/reference/ItemCreateContext.java

@@ -0,0 +1,112 @@
+package com.wolfyscript.utilities.bukkit.world.items.reference;
+
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.util.Optional;
+
+public interface ItemCreateContext {
+
+    int amount();
+
+    default Optional<StackReference> reference() {
+        return Optional.empty();
+    }
+
+    default Optional<Player> player() {
+        return Optional.empty();
+    }
+
+    default Optional<World> world() {
+        return Optional.empty();
+    }
+
+    /**
+     * An empty implementation only containing the required values.
+     *
+     * @return An empty context only containing the required values
+     */
+    static ItemCreateContext empty(int amount) {
+        return () -> amount;
+    }
+
+    static Builder of(int amount) {
+        return new Builder.BuilderImpl(amount);
+    }
+
+    static Builder of(StackReference reference) {
+        return of(reference.amount()).reference(reference);
+    }
+
+    /**
+     * Builder to construct an ItemCreateContext
+     *
+     */
+    interface Builder {
+
+        Builder reference(StackReference reference);
+
+        Builder player(Player player);
+
+        Builder world(World world);
+
+        ItemCreateContext build();
+
+        class BuilderImpl implements Builder {
+
+            private final int amount;
+            private StackReference reference;
+            private Player player;
+            private World world;
+
+            public BuilderImpl(int amount) {
+                this.amount = amount;
+            }
+
+            @Override
+            public Builder reference(StackReference reference) {
+                this.reference = reference;
+                return this;
+            }
+
+            @Override
+            public Builder player(Player player) {
+                this.player = player;
+                return this;
+            }
+
+            @Override
+            public Builder world(World world) {
+                this.world = world;
+                return this;
+            }
+
+            @Override
+            public ItemCreateContext build() {
+                return new ItemCreateContext() {
+                    @Override
+                    public int amount() {
+                        return amount;
+                    }
+
+                    @Override
+                    public Optional<StackReference> reference() {
+                        return Optional.ofNullable(reference);
+                    }
+
+                    @Override
+                    public Optional<Player> player() {
+                        return Optional.ofNullable(player);
+                    }
+
+                    @Override
+                    public Optional<World> world() {
+                        return Optional.ofNullable(world);
+                    }
+                };
+            }
+        }
+
+    }
+
+}