Made the set of NBT more flexible

Made so could be expanded in the future, but should still just be an light wight option to NBTAPI.

Author: broken1arrow

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/utility/UnbreakableUtil.java

@@ -1,5 +1,7 @@
 package org.broken.arrow.library.itemcreator.utility;
 
+import org.broken.arrow.library.itemcreator.utility.compound.CompoundTag;
+import org.broken.arrow.library.itemcreator.utility.compound.NbtData;
 import org.broken.arrow.library.logging.Logging;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -8,9 +10,7 @@
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 
 public final class UnbreakableUtil {
     private static final Logging logger = new Logging(UnbreakableUtil.class);
@@ -40,7 +40,6 @@ public static ItemMeta applyToMeta(@Nullable final ItemMeta meta, final boolean
             meta.setUnbreakable(unbreakable);
             return meta;
         }
-        if (!NMS_NBT_BRIDGE.isReflectionReady()) return meta;
 
         Material original = getMetaType(meta);
         if (original == null || original == Material.AIR) original = Material.STONE;
@@ -72,8 +71,6 @@ public static ItemStack applyToItem(@Nullable final ItemStack item, final boolea
             return item;
         }
 
-        if (!NMS_NBT_BRIDGE.isReflectionReady()) return item;
-
         try {
             return NMS_NBT_BRIDGE.applyUnbreakableTag(item, "Unbreakable", unbreakable);
         } catch (InvocationTargetException | IllegalAccessException | InstantiationException t) {
@@ -98,7 +95,6 @@ public static boolean isUnbreakable(@Nullable final ItemStack item) {
             final ItemMeta itemMeta = item.getItemMeta();
             return itemMeta != null && itemMeta.isUnbreakable();
         } else {
-            if (!NMS_NBT_BRIDGE.isReflectionReady()) return false;
             try {
                 return NMS_NBT_BRIDGE.hasBooleanTag(item, "Unbreakable");
             } catch (InvocationTargetException | IllegalAccessException | InstantiationException e) {
@@ -136,17 +132,7 @@ private static Material getMetaType(@Nonnull final ItemMeta meta) {
      * <p>Otherwise it dynamically resolves required CraftBukkit and NMS classes
      * and methods.</p>
      */
-    private static class NmsNbtBridge {
-        private Method asNMSCopyMethod;
-        private Method asBukkitCopyMethod;
-        private Method hasTagMethod;
-        private Method getTagMethod;
-        private Method setTagMethod;
-        private Method setBooleanMethod;
-        private Method getBooleanMethod;
-        private Constructor<?> nbtTagConstructor;
-
-        private boolean reflectionReady;
+    public static class NmsNbtBridge {
         private boolean modernSupported;
 
         /**
@@ -162,42 +148,17 @@ private NmsNbtBridge() {
             } catch (ClassNotFoundException | NoSuchMethodException ignored) {
                 this.modernSupported = false;
             }
-            if (this.modernSupported) return;
-            loadLegacyReflection();
-        }
-
-        public Method getAsBukkitCopyMethod() {
-            return asBukkitCopyMethod;
-        }
-
-        public Method getHasTagMethod() {
-            return hasTagMethod;
-        }
-
-        public Method getTagMethod() {
-            return getTagMethod;
-        }
-
-        public Method getSetTagMethod() {
-            return setTagMethod;
-        }
-
-        public Method getSetBooleanMethod() {
-            return setBooleanMethod;
-        }
-
-        public Method getBooleanMethod() {
-            return getBooleanMethod;
-        }
-
-        public Constructor<?> getNbtTagConstructor() {
-            return nbtTagConstructor;
-        }
-
-        public boolean isReflectionReady() {
-            return reflectionReady;
         }
 
+        /**
+         * Indicates whether the current server version supports the modern
+         * Bukkit API method {@code ItemMeta#setUnbreakable(boolean)}.
+         *
+         * <p>If this returns {@code true}, no reflection or NMS handling is required
+         * and this bridge will remain inactive.</p>
+         *
+         * @return {@code true} if the modern API is available, otherwise {@code false}
+         */
         public boolean isModernSupported() {
             return modernSupported;
         }
@@ -212,137 +173,31 @@ public boolean isModernSupported() {
          * @return a new Bukkit ItemStack instance with updated NBT
          */
         public ItemStack applyUnbreakableTag(@Nonnull final ItemStack item, @Nonnull final String key, final boolean unbreakable) throws InvocationTargetException, IllegalAccessException, InstantiationException {
-            Object nmsItem = this.toNmsItemStack(item);
-            this.applyBooleanTag(nmsItem, key, unbreakable);
-            return (ItemStack) this.getAsBukkitCopyMethod().invoke(null, nmsItem);
+            NbtData nms = new NbtData(item);
+            if(!nms.isReflectionReady()) return item;
+
+            CompoundTag compound = nms.getOrCreateCompound();
+            compound.setBoolean(key,unbreakable);
+            return nms.apply(compound);
         }
 
         /**
          * Checks whether the given Bukkit item contains the specified
-         * boolean NBT key.
+         * NBT key.
          *
          * @param item Bukkit ItemStack
          * @param key  NBT key
          * @return {@code true} if the key exists and is set to {@code true}
          */
         public boolean hasBooleanTag(@Nonnull final ItemStack item, @Nonnull String key) throws InvocationTargetException, IllegalAccessException, InstantiationException {
-            Object nmsItem = this.toNmsItemStack(item);
-            if (!(Boolean) this.getHasTagMethod().invoke(nmsItem)) {
-                return false;
-            }
-            Object tag = this.getOrCreateNbtTag(nmsItem);
-            return (Boolean) this.getBooleanMethod().invoke(tag, key);
-        }
-
-        /**
-         * Applies a boolean tag to an NMS ItemStack.
-         *
-         * @param nmsItem     the nms stack.
-         * @param key         the key to set
-         * @param unbreakable if it set to {@code true} it will be unbreakable, otherwise the tool can break.
-         */
-        public void applyBooleanTag(@Nonnull final Object nmsItem, @Nonnull final String key, final boolean unbreakable) throws InvocationTargetException, IllegalAccessException, InstantiationException {
-            final Object tag = this.getOrCreateNbtTag(nmsItem);
-            this.setBooleanTag(tag, key, unbreakable);
-            this.applyTagCompound(nmsItem, tag);
-        }
-
-        /**
-         * Applies an NBT compound to an NMS ItemStack.
-         *
-         * @param nmsItem the nms stack.
-         * @param tag     the NBTTagCompound to be set.
-         */
-        public void applyTagCompound(@Nonnull final Object nmsItem, @Nonnull final Object tag) throws InvocationTargetException, IllegalAccessException {
-            getSetTagMethod().invoke(nmsItem, tag);
-        }
+            NbtData nms = new NbtData(item);
+            if(!nms.isReflectionReady()) return false;
 
-        /**
-         * Sets a boolean inside an NBTTagCompound.
-         *
-         * @param tag         the NBTTagCompound to be set.
-         * @param key         the key to set
-         * @param unbreakable if it shall be true or false.
-         */
-        public void setBooleanTag(@Nonnull final Object tag, @Nonnull final String key, final boolean unbreakable) throws InvocationTargetException, IllegalAccessException {
-            getSetBooleanMethod().invoke(tag, key, unbreakable);
-        }
-
-        /**
-         * Returns the existing NBTTagCompound if one is present,
-         * otherwise creates a new one.
-         *
-         * @param nmsItem the nms stack.
-         * @return the NBTTagCompound if exist or create new one.
-         */
-        public Object getOrCreateNbtTag(@Nonnull final Object nmsItem) throws InvocationTargetException, IllegalAccessException, InstantiationException {
-            boolean hasTag = (boolean) hasTagMethod.invoke(nmsItem);
-            return hasTag
-                    ? getTagMethod.invoke(nmsItem)
-                    : nbtTagConstructor.newInstance();
-        }
-
-        /**
-         * Resolves all CraftBukkit and NMS classes and methods using reflection.
-         * This is only required for legacy versions.
-         */
-        private void loadLegacyReflection() {
-            try {
-
-                String craftPath = getCraftBukkitPath();
-
-                final Class<?> craftItemStackClass = Class.forName(craftPath + ".inventory.CraftItemStack");
-                asNMSCopyMethod = craftItemStackClass.getMethod("asNMSCopy", ItemStack.class);
-                asBukkitCopyMethod = craftItemStackClass.getMethod("asBukkitCopy", Class.forName(getMinecraftPath() + ".ItemStack"));
-
-                final Class<?> nbtTagCompoundClass = Class.forName(getMinecraftPath() + ".NBTTagCompound");
-
-                nbtTagConstructor = nbtTagCompoundClass.getConstructor();
-
-                Class<?> nmsStackClass = Class.forName(getMinecraftPath() + ".ItemStack");
-
-                hasTagMethod = nmsStackClass.getMethod("hasTag");
-                getTagMethod = nmsStackClass.getMethod("getTag");
-                setTagMethod = nmsStackClass.getMethod("setTag", nbtTagCompoundClass);
-                setBooleanMethod = nbtTagCompoundClass.getMethod("setBoolean", String.class, boolean.class);
-                getBooleanMethod = nbtTagCompoundClass.getMethod("getBoolean", String.class);
-
-                reflectionReady = true;
-            } catch (ClassNotFoundException | NoSuchMethodException t) {
-                logger.logError(t, () -> "Could not resolve the unbreakable tag for this minecraft version");
-                reflectionReady = false;
+            final CompoundTag compound =  nms.getCompound();
+            if (compound == null) {
+                return false;
             }
-        }
-
-        private String getMinecraftPath() {
-            return "net.minecraft.server."
-                    + getPackageVersion();
-        }
-
-        private String getCraftBukkitPath() {
-            return "org.bukkit.craftbukkit." + getPackageVersion();
-        }
-
-        /**
-         * Extracts the version identifier from the Bukkit server package.
-         * This version will only work on legacy, as the path changed in newer
-         * minecraft versions.
-         * Example: v1_8_R3
-         *
-         * @return it returns for example v1_8_R3
-         */
-        private String getPackageVersion() {
-            return Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-        }
-
-        /**
-         * Converts a Bukkit ItemStack into its NMS counterpart.
-         *
-         * @param item Bukkit ItemStack to convert.
-         * @return the underlying Nms itemStack.
-         */
-        private Object toNmsItemStack(@Nonnull final ItemStack item) throws IllegalAccessException, InvocationTargetException {
-            return this.asNMSCopyMethod.invoke(null, item);
+            return compound.hasKey(key);
         }
 
     }

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/utility/compound/CompoundTag.java

@@ -0,0 +1,115 @@
+package org.broken.arrow.library.itemcreator.utility.compound;
+
+import org.broken.arrow.library.logging.Logging;
+import org.broken.arrow.library.logging.Validate;
+
+import javax.annotation.Nonnull;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Wraps an underlying NBTTagCompound belonging to an NMS ItemStack.
+ *
+ * <p>This is <b>not</b> intended for normal plugin-specific NBT storage.
+ * It is used to modify low-level, vanilla-controlled item properties
+ * which are otherwise inaccessible through the Bukkit API in legacy
+ * Minecraft versions.</p>
+ *
+ * <p>Examples include keys such as {@code "Unbreakable"} that affect the
+ * behaviour of the actual item, not just custom plugin data.</p>
+ *
+ * <p>This class is backed by reflection. If the required NMS classes or
+ * methods cannot be resolved, operations will fail silently (with logging)
+ * and no changes will be applied to the compound.</p>
+ *
+ */
+public final class CompoundTag {
+    private static final Logging logger = new Logging(CompoundTag.class);
+    private static final Method hasKey;
+    private static final Method setBoolean;
+    private static final Method getBoolean;
+    private final Object handle;
+
+    static {
+        Method hasTagKey = null;
+        Method setBooleanM = null;
+        Method getBooleanM = null;
+        try {
+            final Class<?> nbtTag = Class.forName(NbtData.getNbtTagPath());
+            hasTagKey = nbtTag.getMethod("hasKey", String.class);
+            setBooleanM = nbtTag.getMethod("setBoolean", String.class, boolean.class);
+            getBooleanM = nbtTag.getMethod("getBoolean", String.class);
+        } catch (ClassNotFoundException | NoSuchMethodException e) {
+            logger.logError(e, () -> "Failed to bind NBT methods");
+        }
+        hasKey = hasTagKey;
+        setBoolean = setBooleanM;
+        getBoolean = getBooleanM;
+
+    }
+
+    CompoundTag(@Nonnull final Object handle) {
+        Validate.checkNotNull(handle, "CompoundTag handle cannot be null");
+        this.handle = handle;
+    }
+
+    /**
+     * This handle is the NBTTagCompound object.
+     *
+     * @return returns the NBTTagCompound object.
+     */
+    @Nonnull
+    Object getHandle() {
+        return handle;
+    }
+
+    /**
+     * Checks whether this {@link CompoundTag} contains the given key.
+     *
+     * @param key the NBT key to check
+     * @return {@code true} if the key exists, otherwise {@code false}
+     */
+    public boolean hasKey(@Nonnull String key) {
+        if (hasKey == null) return false;
+
+        try {
+            return (boolean) hasKey.invoke(handle, key);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            logger.logError(e, () -> "Failed to check if the compound have the key.");
+        }
+        return false;
+    }
+
+    /**
+     * Sets a boolean value in the underlying NBTTagCompound.
+     *
+     * @param key   the key to set
+     * @param value the boolean value to assign
+     */
+    public void setBoolean(@Nonnull String key, boolean value) {
+        if (setBoolean == null) return;
+
+        try {
+            setBoolean.invoke(handle, key, value);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            logger.logError(e, () -> "Failed to set boolean value from reflection");
+        }
+    }
+
+    /**
+     * Gets a boolean value from the underlying NBTTagCompound.
+     *
+     * @param key the key of the boolean value
+     * @return the stored boolean value, or {@code false} if unavailable
+     */
+    public boolean getBoolean(@Nonnull String key) {
+        if (getBoolean == null) return false;
+
+        try {
+            return (boolean) getBoolean.invoke(handle, key);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            logger.logError(e, () -> "Failed to retrieve boolean value from reflection");
+        }
+        return false;
+    }
+}