add some more methods to ListTag and some smaller renamings

Cubeside · Aug 16, 2023 · 9f16de6 · 9f16de6
1 parent 288cc7f
commit 9f16de6
Show file tree

Hide file tree

Showing 5 changed files with 215 additions and 15 deletions.
diff --git a/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/CompoundTag.java b/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/CompoundTag.java
@@ -5,13 +5,13 @@
 
 public interface CompoundTag {
 
-    boolean containsKey(String key);
+    boolean containsKey(String name);
 
-    boolean containsKey(String key, TagType type);
+    boolean containsKey(String name, TagType type);
 
     void clear();
 
-    void remove(String string);
+    void remove(String name);
 
     Set<String> getAllKeys();
 
@@ -85,6 +85,8 @@ public interface CompoundTag {
 
     void setString(String name, String v);
 
+    boolean containsUUID(String name);
+
     UUID getUUID(String name);
 
     void setUUID(String name, UUID value);
@@ -94,5 +96,4 @@ public interface CompoundTag {
 
     @Override
     boolean equals(Object obj);
-
 }
diff --git a/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/ListTag.java b/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/ListTag.java
@@ -1,5 +1,7 @@
 package de.cubeside.nmsutils.nbt;
 
+import java.util.UUID;
+
 public interface ListTag {
     int size();
 
@@ -82,4 +84,54 @@ public interface ListTag {
     boolean addDouble(int index, double v);
 
     boolean setDouble(int index, double v);
+
+    byte[] getByteArray(int index);
+
+    byte[] getByteArray(int index, byte[] defaultValue);
+
+    boolean addByteArray(byte[] v);
+
+    boolean addByteArray(int index, byte[] v);
+
+    boolean setByteArray(int index, byte[] v);
+
+    int[] getIntArray(int index);
+
+    int[] getIntArray(int index, int[] defaultValue);
+
+    boolean addIntArray(int[] v);
+
+    boolean addIntArray(int index, int[] v);
+
+    boolean setIntArray(int index, int[] v);
+
+    long[] getLongArray(int index);
+
+    long[] getLongArray(int index, long[] defaultValue);
+
+    boolean addLongArray(long[] v);
+
+    boolean addLongArray(int index, long[] v);
+
+    boolean setLongArray(int index, long[] v);
+
+    String getString(int index);
+
+    String getString(int index, String defaultValue);
+
+    boolean addString(String v);
+
+    boolean addString(int index, String v);
+
+    boolean setString(int index, String v);
+
+    UUID getUUID(int index);
+
+    UUID getUUID(int index, UUID defaultValue);
+
+    boolean addUUID(UUID v);
+
+    boolean addUUID(int index, UUID v);
+
+    boolean setUUID(int index, UUID v);
 }
diff --git a/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/TagType.java b/nmsutils-core/src/main/java/de/cubeside/nmsutils/nbt/TagType.java
@@ -13,8 +13,7 @@ public enum TagType {
     COMPOUND(10),
     INT_ARRAY(11),
     LONG_ARRAY(12),
-    ANY_NUMERIC(99),
-    UUID(-1);
+    ANY_NUMERIC(99);
 
     private final int internalId;
     private static final TagType[] byInternal = new TagType[12];

diff --git a/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/CompoundTagImpl.java b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/CompoundTagImpl.java
@@ -22,16 +22,13 @@ public CompoundTagImpl(CompoundTag handle) {
     }
 
     @Override
-    public boolean containsKey(String key) {
-        return handle.contains(key);
+    public boolean containsKey(String name) {
+        return handle.contains(name);
     }
 
     @Override
-    public boolean containsKey(String key, TagType type) {
-        if (type == TagType.UUID) {
-            return handle.hasUUID(key);
-        }
-        return handle.contains(key, type.internalId());
+    public boolean containsKey(String name, TagType type) {
+        return handle.contains(name, type.internalId());
     }
 
     @Override
@@ -40,8 +37,8 @@ public void clear() {
     }
 
     @Override
-    public void remove(String string) {
-        handle.remove(string);
+    public void remove(String name) {
+        handle.remove(name);
     }
 
     @Override
@@ -291,6 +288,11 @@ public UUID getUUID(String name) {
         return handle.hasUUID(name) ? handle.getUUID(name) : null;
     }
 
+    @Override
+    public boolean containsUUID(String name) {
+        return handle.hasUUID(name);
+    }
+
     @Override
     public void setUUID(String name, UUID v) {
         Preconditions.checkNotNull(name);

diff --git a/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/ListTagImpl.java b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/ListTagImpl.java
@@ -1,15 +1,21 @@
 package de.cubeside.nmsutils.v1_20_R1;
 
 import de.cubeside.nmsutils.nbt.TagType;
+import java.util.UUID;
+import net.minecraft.nbt.ByteArrayTag;
 import net.minecraft.nbt.ByteTag;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.DoubleTag;
 import net.minecraft.nbt.FloatTag;
+import net.minecraft.nbt.IntArrayTag;
 import net.minecraft.nbt.IntTag;
 import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.LongArrayTag;
 import net.minecraft.nbt.LongTag;
+import net.minecraft.nbt.NbtUtils;
 import net.minecraft.nbt.NumericTag;
 import net.minecraft.nbt.ShortTag;
+import net.minecraft.nbt.StringTag;
 
 public final class ListTagImpl implements de.cubeside.nmsutils.nbt.ListTag {
     final ListTag handle;
@@ -251,6 +257,146 @@ public boolean setDouble(int index, double v) {
         return handle.setTag(index, DoubleTag.valueOf(v));
     }
 
+    @Override
+    public byte[] getByteArray(int index) {
+        return getByteArray(index, null);
+    }
+
+    @Override
+    public byte[] getByteArray(int index, byte[] defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof ByteArrayTag t) {
+            return t.getAsByteArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addByteArray(byte[] v) {
+        return addByteArray(size(), v);
+    }
+
+    @Override
+    public boolean addByteArray(int index, byte[] v) {
+        return handle.addTag(index, new ByteArrayTag(v));
+    }
+
+    @Override
+    public boolean setByteArray(int index, byte[] v) {
+        return handle.setTag(index, new ByteArrayTag(v));
+    }
+
+    @Override
+    public int[] getIntArray(int index) {
+        return getIntArray(index, null);
+    }
+
+    @Override
+    public int[] getIntArray(int index, int[] defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof IntArrayTag t) {
+            return t.getAsIntArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addIntArray(int[] v) {
+        return addIntArray(size(), v);
+    }
+
+    @Override
+    public boolean addIntArray(int index, int[] v) {
+        return handle.addTag(index, new IntArrayTag(v));
+    }
+
+    @Override
+    public boolean setIntArray(int index, int[] v) {
+        return handle.setTag(index, new IntArrayTag(v));
+    }
+
+    @Override
+    public long[] getLongArray(int index) {
+        return getLongArray(index, null);
+    }
+
+    @Override
+    public long[] getLongArray(int index, long[] defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof LongArrayTag t) {
+            return t.getAsLongArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addLongArray(long[] v) {
+        return addLongArray(size(), v);
+    }
+
+    @Override
+    public boolean addLongArray(int index, long[] v) {
+        return handle.addTag(index, new LongArrayTag(v));
+    }
+
+    @Override
+    public boolean setLongArray(int index, long[] v) {
+        return handle.setTag(index, new LongArrayTag(v));
+    }
+
+    @Override
+    public String getString(int index) {
+        return getString(index, null);
+    }
+
+    @Override
+    public String getString(int index, String defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof StringTag t) {
+            return t.getAsString();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addString(String v) {
+        return addString(size(), v);
+    }
+
+    @Override
+    public boolean addString(int index, String v) {
+        return handle.addTag(index, StringTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setString(int index, String v) {
+        return handle.setTag(index, StringTag.valueOf(v));
+    }
+
+    @Override
+    public UUID getUUID(int index) {
+        return getUUID(index, null);
+    }
+
+    @Override
+    public UUID getUUID(int index, UUID defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof IntArrayTag t && t.size() == 4) {
+            return NbtUtils.loadUUID(t);
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addUUID(UUID v) {
+        return addUUID(size(), v);
+    }
+
+    @Override
+    public boolean addUUID(int index, UUID v) {
+        return handle.addTag(index, NbtUtils.createUUID(v));
+    }
+
+    @Override
+    public boolean setUUID(int index, UUID v) {
+        return handle.setTag(index, NbtUtils.createUUID(v));
+    }
+
     public void remove(int i) {
         handle.remove(i);
     }