Added some useful codecs

Author: jtljac

README.md

@@ -37,7 +37,11 @@ AgeUtil
 
 DatChatFormatting
 > A set of standardised chat colours for consistently formatting chat messages
->
+
+DatCodec
+> A few useful codecs for serialising common values
+> 
+> Currently Implemented: UUID, Enums, ChunkPos
 
 DatMessageFormatter
 > A utility for formatting strings into chat Components using variable replacements and shorthands for formatting directives

src/main/java/com/datdeveloper/datmoddingapi/util/DatCodec.java

@@ -0,0 +1,56 @@
+package com.datdeveloper.datmoddingapi.util;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import net.minecraft.Util;
+import net.minecraft.world.level.ChunkPos;
+
+import java.util.UUID;
+import java.util.stream.IntStream;
+
+/**
+ * A utility class containing various useful codecs
+ */
+public class DatCodec {
+    /**
+     * A Codec for handling UUID
+     * <br>
+     * Converts it into a string for storage
+     */
+    public static final Codec<UUID> UUID_CODEC = Codec.STRING.comapFlatMap(s -> {
+        try {
+            return DataResult.success(UUID.fromString(s));
+        } catch (final IllegalArgumentException e) {
+            return DataResult.error(() -> s + " is not a UUID.");
+        }
+    }, UUID::toString);
+
+    /**
+     * A helper function to create a Codec that handles the given enum class
+     * <br>
+     * The resulting codec will convert the enum into a string for storage
+     * @param enumClass The class of the enum
+     * @return A Codec that handles the given enum class
+     * @param <E> The Enum Type
+     */
+    public static <E extends Enum<E>> Codec<E> getEnumCodec(final Class<E> enumClass) {
+        return Codec.STRING.comapFlatMap(string -> {
+            try {
+                return DataResult.success(E.valueOf(enumClass, string));
+            } catch (final IllegalArgumentException e) {
+                return DataResult.error(() -> string + " is not an instance of the enum");
+            }
+        }, E::name);
+    }
+
+    /**
+     * A Codec for handling ChunkPos
+     * <br>
+     * This converts the chunkpos into an intstream, similar to {@link net.minecraft.core.BlockPos}
+     * @see net.minecraft.core.BlockPos
+     */
+    public static final Codec<ChunkPos> CHUNKPOS = Codec.INT_STREAM.comapFlatMap(stream ->
+            Util.fixedSize(stream, 2).map((ints -> new ChunkPos(ints[0], ints[1]))),
+            chunkPos -> IntStream.of(chunkPos.x, chunkPos.z)
+    );
+}

src/test/java/com/datdeveloper/TestCodecs.java

@@ -0,0 +1,142 @@
+package com.datdeveloper;
+
+import com.datdeveloper.datmoddingapi.util.DatCodec;
+import com.datdeveloper.datmoddingapi.util.ENotificationType;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.mojang.serialization.JsonOps;
+import net.minecraft.world.level.ChunkPos;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public class TestCodecs {
+    /**
+     * Test UUID Correctly converts to Json
+     */
+    @Test
+    void testUuidToJson() {
+        final UUID uuid = UUID.randomUUID();
+
+        final Optional<JsonElement> result = DatCodec.UUID_CODEC.encodeStart(JsonOps.INSTANCE, uuid).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(uuid.toString(), result.get().getAsString());
+    }
+
+    /**
+     * Test Json correctly converts into UUID
+     */
+    @Test
+    void testJsonToUuid() {
+        final UUID uuid = UUID.randomUUID();
+
+        final Gson gson = new Gson();
+        final JsonElement object = gson.toJsonTree(uuid.toString());
+
+        final Optional<UUID> result = DatCodec.UUID_CODEC.parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(uuid, result.get());
+    }
+
+    /**
+     * Test Json to UUID correctly handles bad UUID
+     */
+    @Test
+    void testBadJsonToUuid() {
+        final Gson gson = new Gson();
+        final JsonElement object = gson.toJsonTree("Totally not a real UUID");
+
+        final Optional<UUID> result = DatCodec.UUID_CODEC.parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertFalse(result.isPresent());
+    }
+
+    /**
+     * Test enum correctly converts to json
+     */
+    @Test
+    void testEnumToJson() {
+        final ENotificationType test = ENotificationType.ACTIONBAR;
+
+        final Optional<JsonElement> result = DatCodec.getEnumCodec(ENotificationType.class).encodeStart(JsonOps.INSTANCE, test).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(test.name(), result.get().getAsString());
+    }
+
+    /**
+     * Test Json correctly converts into Enum
+     */
+    @Test
+    void testJsonToEnum() {
+        final ENotificationType test = ENotificationType.ACTIONBAR;
+
+        final Gson gson = new Gson();
+        final JsonElement object = gson.toJsonTree(test.name());
+
+        final Optional<ENotificationType> result = DatCodec.getEnumCodec(ENotificationType.class).parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(test, result.get());
+    }
+
+    /**
+     * Test Json to enum correctly handles bad enum
+     */
+    @Test
+    void testBadJsonToEnum() {
+        final Gson gson = new Gson();
+        final JsonElement object = gson.toJsonTree("Totally not a real ENotificationType");
+
+        final Optional<ENotificationType> result = DatCodec.getEnumCodec(ENotificationType.class).parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertFalse(result.isPresent());
+    }
+
+    /**
+     * Test ChunkPos correctly converts to json
+     */
+    @Test
+    void testChunkPosToJson() {
+        final ChunkPos chunkPos = new ChunkPos(5, 12);
+
+        final Optional<JsonElement> result = DatCodec.CHUNKPOS.encodeStart(JsonOps.INSTANCE, chunkPos).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals("[" + chunkPos.x + "," + chunkPos.z + "]", result.get().toString());
+    }
+
+    /**
+     * Test Json correctly converts into ChunkPos
+     */
+    @Test
+    void testJsonToChunkPos() {
+
+        final ChunkPos chunkPos = new ChunkPos(5, 12);
+        final Gson gson = new Gson();
+        final JsonElement object = gson.fromJson("[" + chunkPos.x + "," + chunkPos.z + "]", JsonArray.class);
+
+        final Optional<ChunkPos> result = DatCodec.CHUNKPOS.parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(chunkPos, result.get());
+    }
+
+    /**
+     * Test Json to enum correctly handles bad enum
+     */
+    @Test
+    void testBadJsonToBlockPos() {
+        final Gson gson = new Gson();
+        final JsonElement object = gson.fromJson("[1,2,3,4,5,6]", JsonArray.class);
+
+        final Optional<ChunkPos> result = DatCodec.CHUNKPOS.parse(JsonOps.INSTANCE, object).result();
+
+        Assertions.assertFalse(result.isPresent());
+    }
+}