[Ornithe] add: Data Tag Utils / NbtKeys, etc.

src/main/java/malilib/mixin/access/TileEntityMixin.java

@@ -0,0 +1,14 @@
+package malilib.mixin.access;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.RegistryNamespaced;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(TileEntity.class)
+public interface TileEntityMixin
+{
+	@Accessor("REGISTRY")
+	RegistryNamespaced<ResourceLocation, Class<? extends TileEntity>> malilib_getTileEntityRegistry();
+}

src/main/java/malilib/util/data/DyeColorCode.java

@@ -1,5 +1,7 @@
 package malilib.util.data;
 
+import net.minecraft.item.EnumDyeColor;
+
 public enum DyeColorCode
 {
     WHITE       ( 0, "§f", "white"),
@@ -56,4 +58,22 @@ public static DyeColorCode getByMeta(int meta)
 
         return COLOR_CODES_BY_META[meta];
     }
+
+    public static DyeColorCode fromStringOrDefault(String name, DyeColorCode defaultValue)
+    {
+        for (DyeColorCode color : COLOR_CODES_BY_META)
+        {
+            if (color.getName().equalsIgnoreCase(name))
+            {
+                return color;
+            }
+        }
+
+        return defaultValue;
+    }
+
+    public EnumDyeColor toVanilla()
+    {
+        return EnumDyeColor.byMetadata(this.meta);
+    }
 }

src/main/java/malilib/util/data/Identifier.java

@@ -1,5 +1,7 @@
 package malilib.util.data;
 
+import java.util.Optional;
+
 import net.minecraft.util.ResourceLocation;
 
 /**
@@ -23,4 +25,14 @@ public Identifier(String namespaceIn, String pathIn)
     {
         super(namespaceIn, pathIn);
     }
+
+    public static Identifier of(String resourceName)
+    {
+        return new Identifier(resourceName);
+    }
+
+    public static Identifier of(String namespaceIn, String pathIn)
+    {
+        return new Identifier(namespaceIn, pathIn);
+    }
 }

src/main/java/malilib/util/data/tag/ArrayData.java

@@ -0,0 +1,64 @@
+package malilib.util.data.tag;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import javax.annotation.Nonnull;
+
+/**
+ * Informs {@link malilib.util.data.tag.util.DataOps} that the inherited class
+ * is an Array Value, and can perform the basic {@link java.util.ArrayList} operations
+ * @implNote They will also need to be Mutable objects.
+ */
+public interface ArrayData extends Iterable<BaseData>
+{
+	void clear();
+
+	boolean set(int index, BaseData entry);
+
+	boolean add(int index, BaseData entry);
+
+	BaseData remove(int index);
+
+	BaseData get(int index);
+
+	int size();
+
+	default boolean isEmpty()
+	{
+		return size() == 0;
+	}
+
+	default @Nonnull Iterator<BaseData> iterator()
+	{
+		return new Iterator<BaseData>()
+		{
+			private int index;
+
+			@Override
+			public boolean hasNext()
+			{
+				return this.index < ArrayData.this.size();
+			}
+
+			@Override
+			public BaseData next()
+			{
+				if (this.hasNext())
+				{
+					return ArrayData.this.get(this.index++);
+				}
+				else
+				{
+					throw new NoSuchElementException();
+				}
+			}
+		};
+	}
+
+	default Stream<BaseData> stream()
+	{
+		return StreamSupport.stream(this.spliterator(), false);
+	}
+}

src/main/java/malilib/util/data/tag/BaseData.java

@@ -3,6 +3,7 @@
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+import java.util.Optional;
 
 import malilib.util.data.Constants;
 import malilib.util.data.tag.util.SizeTracker;
@@ -30,6 +31,15 @@ public String getDisplayName()
 
     public abstract BaseData copy();
 
+    public abstract String toString();
+
+    public abstract boolean isEmpty();
+
+    public Optional<Number> asNumber()
+    {
+        return Optional.empty();
+    }
+
     public abstract void write(DataOutput output) throws IOException;
 
     public static BaseData createTag(int tagType, DataInput input, int depth, SizeTracker sizeTracker) throws IOException
@@ -48,6 +58,7 @@ public static BaseData createTag(int tagType, DataInput input, int depth, SizeTr
             case Constants.NBT.TAG_LONG_ARRAY:  return LongArrayData.read(input, depth, sizeTracker);
             case Constants.NBT.TAG_COMPOUND:    return CompoundData.read(input, depth, sizeTracker);
             case Constants.NBT.TAG_LIST:        return ListData.read(input, depth, sizeTracker);
+            case Constants.NBT.TAG_END:         return EmptyData.read(input, depth, sizeTracker);
             default:
                 throw new IOException("Unknown tag type " + tagType);
         }

src/main/java/malilib/util/data/tag/ByteArrayData.java

@@ -8,7 +8,8 @@
 import malilib.util.data.Constants;
 import malilib.util.data.tag.util.SizeTracker;
 
-public class ByteArrayData extends BaseData
+public class ByteArrayData extends BaseData // implements ArrayData
+    // todo ArrayData
 {
     public static final String TAG_NAME = "TAG_ByteArray";
 
@@ -52,6 +53,83 @@ public String toString()
         return sb.append(']').toString();
     }
 
+    @Override
+    public boolean isEmpty()
+    {
+        return this.value.length == 0;
+    }
+
+    // todo ArrayData
+//    @Override
+//    public void clear()
+//    {
+//        this.value = new byte[0];
+//    }
+//
+//    @Override
+//    public boolean set(int index, BaseData entry)
+//    {
+//        Optional<Number> opt = entry.asNumber();
+//
+//        if (index < this.size() &&
+//            index >= 0 &&
+//            opt.isPresent())
+//        {
+//            this.value[index] = opt.get().byteValue();
+//            return true;
+//        }
+//
+//        return false;
+//    }
+//
+//    @Override
+//    public boolean add(int index, BaseData entry)
+//    {
+//        Optional<Number> opt = entry.asNumber();
+//
+//        if (index < this.size() &&
+//            index >= 0 &&
+//            opt.isPresent())
+//        {
+//            this.value = ArrayUtils.add(this.value, index, opt.get().byteValue());
+//            return true;
+//        }
+//
+//        return false;
+//    }
+//
+//    @Override
+//    @Nullable
+//    public ByteData remove(int index)
+//    {
+//        if (index < this.size() && index >= 0)
+//        {
+//            byte entry = this.value[index];
+//            this.value = ArrayUtils.remove(this.value, index);
+//            return new ByteData(entry);
+//        }
+//
+//        return null;
+//    }
+//
+//    @Override
+//    @Nullable
+//    public ByteData get(int index)
+//    {
+//        if (index < this.size() && index >= 0)
+//        {
+//            return new ByteData(this.value[index]);
+//        }
+//
+//        return null;
+//    }
+//
+//    @Override
+//    public int size()
+//    {
+//        return this.value.length;
+//    }
+
     @Override
     public void write(DataOutput output) throws IOException
     {

src/main/java/malilib/util/data/tag/ByteData.java

@@ -3,11 +3,12 @@
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+import java.util.Optional;
 
 import malilib.util.data.Constants;
 import malilib.util.data.tag.util.SizeTracker;
 
-public class ByteData extends BaseData
+public class ByteData extends BaseData implements NumberData
 {
     public static final String TAG_NAME = "TAG_Byte";
 
@@ -37,6 +38,18 @@ public String toString()
         return this.value + "b";
     }
 
+    @Override
+    public boolean isEmpty()
+    {
+        return false;
+    }
+
+    @Override
+    public Optional<Number> asNumber()
+    {
+        return Optional.of(this.value);
+    }
+
     @Override
     public void write(DataOutput output) throws IOException
     {

src/main/java/malilib/util/data/tag/CompoundData.java

@@ -52,6 +52,11 @@ public Set<String> getKeys()
         return this.values.keySet();
     }
 
+    public Set<Map.Entry<String, BaseData>> entrySet()
+    {
+        return this.values.entrySet();
+    }
+
     @Override
     public boolean contains(String key, int requestedType)
     {
@@ -263,7 +268,6 @@ public ListData getList(String key, int containedType)
         return data != null && data.getType() == Constants.NBT.TAG_LIST ? (ListData) data : new ListData(containedType);
     }
 
-
     public CompoundData putBoolean(String key, boolean value)
     {
         this.values.put(key, new ByteData(value ? (byte) 1 : 0));
@@ -358,6 +362,33 @@ public CompoundData copy()
         return copy;
     }
 
+    // Primarily needed for DataOps, but can be utilized for other things
+    public CompoundData combine(CompoundData other)
+    {
+        if (other == null || other.isEmpty())
+        {
+            return this.copy();
+        }
+
+        for (String key : other.values.keySet())
+        {
+            BaseData data = other.values.get(key);
+
+            if (data.getType() == Constants.NBT.TAG_COMPOUND &&
+                this.values.containsKey(key) &&
+                this.values.get(key).getType() == Constants.NBT.TAG_COMPOUND)
+            {
+                CompoundData out = ((CompoundData) this.values.get(key)).combine((CompoundData) data);
+                this.values.put(key, out);
+                continue;
+            }
+
+            this.values.put(key, data);
+        }
+
+        return this.copy();
+    }
+
     @Override
     public String toString()
     {
@@ -459,6 +490,28 @@ public boolean equals(Object o)
         CompoundData other = (CompoundData) o;
 
         return Objects.equals(this.values, other.values);
+
+        // todo
+//        // Match any member of the compound using equals(),
+//        // in any insertion order.
+//        if (o instanceof CompoundData data)
+//        {
+//            boolean result = false;
+//
+//            for (String key : this.getKeys())
+//            {
+//                result = this.values.get(key).equals(data.values.get(key));
+//
+//                if (!result)
+//                {
+//                    break;
+//                }
+//            }
+//
+//            return result;
+//        }
+//
+//        return false;
     }
 
     @Override

src/main/java/malilib/util/data/tag/DataView.java

@@ -45,7 +45,6 @@ public interface DataView
 
     ListData getList(String key, int containedType);
 
-
     default boolean getBooleanOrDefault(String key, boolean defaultValue)
     {
         if (this.contains(key, Constants.NBT.TAG_BYTE) == false)