Merge pull request #1 from iBuyMountainDew/rewrite

Rewrite for 1.3.0

Author: BitBuf

README.md

@@ -3,7 +3,7 @@
   <br>
 </h1>
 
-<h4 align="center">Basic library for reading and writing Minecraft's NBT format.</h4>
+<h4 align="center">Flexible and intuitive library for reading and writing Minecraft's NBT format.</h4>
 
 <p align="center">
   <a href="#overview">Overview</a>
@@ -23,18 +23,18 @@ NBT (Named Binary Tag) is a binary format devised by Notch to be Minecraft's pri
 
 There are 12 types of tag that can be used in a complaint NBT file (see [TagType.java](src/main/java/dev/dewy/nbt/utils/TagType.java) for descriptions of each):
 
-- [Byte](src/main/java/dev/dewy/nbt/tags/number/ByteTag.java)
-- [Short](src/main/java/dev/dewy/nbt/tags/number/ShortTag.java)
-- [Int](src/main/java/dev/dewy/nbt/tags/number/IntTag.java)
-- [Long](src/main/java/dev/dewy/nbt/tags/number/LongTag.java)
-- [Float](src/main/java/dev/dewy/nbt/tags/number/FloatTag.java)
-- [Double](src/main/java/dev/dewy/nbt/tags/number/DoubleTag.java)
+- [Byte](src/main/java/dev/dewy/nbt/tags/primitive/ByteTag.java)
+- [Short](src/main/java/dev/dewy/nbt/tags/primitive/ShortTag.java)
+- [Int](src/main/java/dev/dewy/nbt/tags/primitive/IntTag.java)
+- [Long](src/main/java/dev/dewy/nbt/tags/primitive/LongTag.java)
+- [Float](src/main/java/dev/dewy/nbt/tags/primitive/FloatTag.java)
+- [Double](src/main/java/dev/dewy/nbt/tags/primitive/DoubleTag.java)
 - [Byte Array](src/main/java/dev/dewy/nbt/tags/array/ByteArrayTag.java)
 - [Int Array](src/main/java/dev/dewy/nbt/tags/array/IntArrayTag.java)
 - [Long Array](src/main/java/dev/dewy/nbt/tags/array/LongArrayTag.java)
-- [String](src/main/java/dev/dewy/nbt/tags/StringTag.java)
-- [List](src/main/java/dev/dewy/nbt/tags/ListTag.java)
-- [Compound](src/main/java/dev/dewy/nbt/tags/CompoundTag.java)                                                       
+- [String](src/main/java/dev/dewy/nbt/tags/primitive/StringTag.java)
+- [List](src/main/java/dev/dewy/nbt/tags/collection/ListTag.java)
+- [Compound](src/main/java/dev/dewy/nbt/tags/collection/CompoundTag.java)                                                       
 
 All valid NBT structures begin with a compound tag; the root compound (abstracted as the [root tag](src/main/java/dev/dewy/nbt/tags/RootTag.java)). Everything else in the NBT structure is a child of this root compound.
 
@@ -48,34 +48,37 @@ repositories {
 }
 
 dependencies {
-    implementation "dev.dewy:nbt:1.2.0"
+    implementation "dev.dewy:nbt:1.3.0"
 }
 ```
 
 #### NBTReader Sample: Base64
 
-The NBTReader class can be used to easily (de)serialize NBT data:
+The [Nbt](src/main/java/dev/dewy/nbt/Nbt.java) class can be used to easily (de)serialize NBT data:
 
 ```java
-RootTag root = NbtReader.fromBase64("CgALaGVsbG8gd29ybGQDAAR0ZXN0AAAAAAA=");
+public static final Nbt NBT = new Nbt();
+```
+
+```java
+CompoundTag test = NBT.fromBase64("CgALaGVsbG8gd29ybGQDAAR0ZXN0AAAAAAA");
 
-System.out.println(root.getName()); // hello world
-System.out.println(root.getCompound().getInt("test").getValue()); // 0
+System.out.println(test.getName()); // hello world
+System.out.println(test.<IntTag>get("test").getValue()); // 0
 ```
 
 See the [NbtTest](src/test/java/dev/dewy/nbt/test/NbtTest.java) class for full sample usage.
 
 ### Features
 
 - Fully compliant with Mojang's "standards"
-- Small and lightweight (32Kb!)
+- Small and lightweight (36Kb!)
 - Supports all Java edition NBT tags (including long array)
 - Intuitive and flexible reading and writing functionality
 
 #### Planned
 
-- SNBT (Stringified NBT) support for Java and Bedrock
-- BNBT (Bedrock NBT) support
+- SNBT (Stringified NBT) support
 - ENBT (Extended NBT) format (missing data types e.g., double array) support
 - JSON (De)serialization
 

build.gradle

@@ -5,7 +5,21 @@ plugins {
 }
 
 group "dev.dewy"
-version "1.2.0"
+version "1.3.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.apache.commons:commons-lang3:$lang3"
+
+    compileOnly "org.projectlombok:lombok:$lombok"
+    annotationProcessor "org.projectlombok:lombok:$lombok"
+
+    testCompileOnly "org.projectlombok:lombok:$lombok"
+    testAnnotationProcessor "org.projectlombok:lombok:$lombok"
+}
 
 task sourcesJar(type: Jar, dependsOn: classes) {
     classifier = "sources"

gradle.properties

@@ -0,0 +1,2 @@
+lombok=1.18.20
+lang3=3.12.0

sample.nbt

@@ -0,0 +1,45 @@
+package dev.dewy.nbt;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Defines the types of compression supported by this library for NBT data.
+ *
+ * @author dewy
+ */
+public enum CompressionType {
+    /**
+     * No compression.
+     */
+    NONE,
+
+    /**
+     * GZIP compression ({@code GZIPInputStream} and {@code GZIPOutputStream}).
+     */
+    GZIP,
+
+    /**
+     * ZLIB compression ({@code InflaterInputStream} and {@code DeflaterOutputStream}).
+     */
+    ZLIB;
+
+    static CompressionType getCompression(InputStream in) throws IOException {
+        if (!in.markSupported()) {
+            in = new BufferedInputStream(in);
+        }
+        in.mark(0);
+
+        if (in.read() == 120) {
+            return ZLIB;
+        }
+
+        in.reset();
+        if (in.read() == 31) {
+            return GZIP;
+        }
+
+        return NONE;
+    }
+}

samplegzip.nbt

@@ -0,0 +1,204 @@
+package dev.dewy.nbt;
+
+import dev.dewy.nbt.tags.collection.CompoundTag;
+import lombok.NonNull;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+import java.util.zip.InflaterInputStream;
+
+/**
+ * Standard interface for reading and writing NBT data structures.
+ *
+ * @author dewy
+ */
+public class Nbt {
+    private @NonNull TagTypeRegistry typeRegistry;
+    private final @NonNull NbtWriter writer;
+    private final @NonNull NbtReader reader;
+
+    /**
+     * Constructs an instance of this class using a default {@link TagTypeRegistry} (supporting the standard 12 tag types).
+     */
+    public Nbt() {
+        this(new TagTypeRegistry());
+    }
+
+    /**
+     * Constructs an instance of this class using a given {@link TagTypeRegistry}.
+     *
+     * @param typeRegistry the tag type registry to be used, typically containing custom tag entries.
+     */
+    public Nbt(@NonNull TagTypeRegistry typeRegistry) {
+        this.typeRegistry = typeRegistry;
+
+        this.writer = new NbtWriter(typeRegistry);
+        this.reader = new NbtReader(typeRegistry);
+    }
+
+    /**
+     * Writes the given root {@link CompoundTag} to a provided {@link DataOutput} stream.
+     *
+     * @param compound the NBT structure to write, contained within a {@link CompoundTag}.
+     * @param output the stream to write to.
+     * @throws IOException if any I/O error occurs.
+     */
+    public void toStream(@NonNull CompoundTag compound, @NonNull DataOutput output) throws IOException {
+        this.writer.toStream(compound, output);
+    }
+
+    /**
+     * Writes the given root {@link CompoundTag} to a {@link File} with no compression.
+     *
+     * @param compound the NBT structure to write, contained within a {@link CompoundTag}.
+     * @param file the file to write to.
+     * @throws IOException if any I/O error occurs.
+     */
+    public void toFile(@NonNull CompoundTag compound, @NonNull File file) throws IOException {
+        this.toFile(compound, file, CompressionType.NONE);
+    }
+
+    /**
+     * Writes the given root {@link CompoundTag} to a {@link File} using a certain {@link CompressionType}.
+     *
+     * @param compound the NBT structure to write, contained within a {@link CompoundTag}.
+     * @param file the file to write to.
+     * @param compression the compression to be applied.
+     * @throws IOException if any I/O error occurs.
+     */
+    public void toFile(@NonNull CompoundTag compound, @NonNull File file, @NonNull CompressionType compression) throws IOException {
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
+        DataOutputStream dos = null;
+
+        switch (compression) {
+            case NONE:
+                dos = new DataOutputStream(bos);
+                break;
+            case GZIP:
+                dos = new DataOutputStream(new GZIPOutputStream(bos));
+                break;
+            case ZLIB:
+                dos = new DataOutputStream(new DeflaterOutputStream(bos));
+        }
+
+        this.toStream(compound, dos);
+        dos.close();
+    }
+
+    /**
+     * Converts the given root {@link CompoundTag} to a {@code byte[]} array.
+     *
+     * @param compound the NBT structure to write, contained within a {@link CompoundTag}.
+     * @return the resulting {@code byte[]} array.
+     * @throws IOException if any I/O error occurs.
+     */
+    public byte[] toByteArray(@NonNull CompoundTag compound) throws IOException {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        DataOutputStream w = new DataOutputStream(new BufferedOutputStream(baos));
+
+        this.toStream(compound, w);
+        w.flush();
+
+        return baos.toByteArray();
+    }
+
+    /**
+     * Converts the given root {@link CompoundTag} to a Base64 encoded string.
+     *
+     * @param compound the NBT structure to write, contained within a {@link CompoundTag}.
+     * @return the resulting Base64 encoded string.
+     * @throws IOException if any I/O error occurs.
+     */
+    public String toBase64(@NonNull CompoundTag compound) throws IOException {
+        return new String(Base64.getEncoder().encode(this.toByteArray(compound)), StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Reads an NBT data structure (root {@link CompoundTag}) from a {@link DataInput} stream.
+     *
+     * @param input the stream to read from.
+     * @return the root {@link CompoundTag} read from the stream.
+     * @throws IOException if any I/O error occurs.
+     */
+    public CompoundTag fromStream(@NonNull DataInput input) throws IOException {
+        return this.reader.fromStream(input);
+    }
+
+    /**
+     * Reads an NBT data structure (root {@link CompoundTag}) from a {@link File}.
+     *
+     * @param file the file to read from.
+     * @return the root {@link CompoundTag} read from the stream.
+     * @throws IOException if any I/O error occurs.
+     */
+    public CompoundTag fromFile(@NonNull File file) throws IOException {
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+        DataInputStream in;
+
+        switch (CompressionType.getCompression(new FileInputStream(file))) {
+            case NONE:
+                in = new DataInputStream(bis);
+                break;
+            case GZIP:
+                in = new DataInputStream(new GZIPInputStream(bis));
+                break;
+            case ZLIB:
+                in = new DataInputStream(new InflaterInputStream(bis));
+                break;
+            default:
+                throw new IllegalStateException("Illegal compression type. This should never happen.");
+        }
+
+        CompoundTag result = this.fromStream(in);
+        in.close();
+
+        return result;
+    }
+
+    /**
+     * Reads an NBT data structure (root {@link CompoundTag}) from a {@code byte[]} array.
+     *
+     * @param bytes the {@code byte[]} array to read from.
+     * @return the root {@link CompoundTag} read from the stream.
+     * @throws IOException if any I/O error occurs.
+     */
+    public CompoundTag fromByteArray(@NonNull byte[] bytes) throws IOException {
+        return fromStream(new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(bytes))));
+    }
+
+    /**
+     * Decodes an NBT data structure (root {@link CompoundTag}) from a Base64 encoded string.
+     *
+     * @param encoded the encoded Base64 string to decode.
+     * @return the decoded root {@link CompoundTag}.
+     * @throws IOException if any I/O error occurs.
+     */
+    public CompoundTag fromBase64(@NonNull String encoded) throws IOException {
+        return fromByteArray(Base64.getDecoder().decode(encoded));
+    }
+
+    /**
+     * Returns the {@link TagTypeRegistry} currently in use by this instance.
+     *
+     * @return the {@link TagTypeRegistry} currently in use by this instance.
+     */
+    public TagTypeRegistry getTypeRegistry() {
+        return typeRegistry;
+    }
+
+    /**
+     * Sets the {@link TagTypeRegistry} currently in use by this instance. Used to utilise custom-made tag types.
+     *
+     * @param typeRegistry the new {@link TagTypeRegistry} to be set.
+     */
+    public void setTypeRegistry(@NonNull TagTypeRegistry typeRegistry) {
+        this.typeRegistry = typeRegistry;
+
+        this.writer.setTypeRegistry(typeRegistry);
+        this.reader.setTypeRegistry(typeRegistry);
+    }
+}