add byte arr, long arr, big int and big decimal sync values

Author: brachy84

src/main/java/com/cleanroommc/modularui/utils/serialization/ByteBufAdapters.java

@@ -12,6 +12,8 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
 
 public class ByteBufAdapters {
 
@@ -22,9 +24,93 @@ public class ByteBufAdapters {
     public static final IByteBufAdapter<ByteBuf> BYTE_BUF = makeAdapter(NetworkUtils::readByteBuf, NetworkUtils::writeByteBuf, null);
     public static final IByteBufAdapter<PacketBuffer> PACKET_BUFFER = makeAdapter(NetworkUtils::readPacketBuffer, NetworkUtils::writeByteBuf, null);
 
+    public static final IByteBufAdapter<byte[]> BYTE_ARR = new IByteBufAdapter<>() {
+        @Override
+        public byte[] deserialize(PacketBuffer buffer) throws IOException {
+            return buffer.readByteArray();
+        }
+
+        @Override
+        public void serialize(PacketBuffer buffer, byte[] u) throws IOException {
+            buffer.writeBytes(u);
+        }
+
+        @Override
+        public boolean areEqual(byte @NotNull [] t1, byte @NotNull [] t2) {
+            if (t1.length != t2.length) return false;
+            for (int i = 0; i < t1.length; i++) {
+                if (t1[i] != t2[i]) return false;
+            }
+            return true;
+        }
+    };
+
+    public static final IByteBufAdapter<long[]> LONG_ARR = new IByteBufAdapter<>() {
+        @Override
+        public long[] deserialize(PacketBuffer buffer) throws IOException {
+            long[] u = new long[buffer.readVarInt()];
+            for (int i = 0; i < u.length; i++) {
+                u[i] = buffer.readLong();
+            }
+            return u;
+        }
+
+        @Override
+        public void serialize(PacketBuffer buffer, long[] u) throws IOException {
+            buffer.writeVarInt(u.length);
+            for (long i : u) {
+                buffer.writeLong(i);
+            }
+        }
+
+        @Override
+        public boolean areEqual(long @NotNull [] t1, long @NotNull [] t2) {
+            if (t1.length != t2.length) return false;
+            for (int i = 0; i < t1.length; i++) {
+                if (t1[i] != t2[i]) return false;
+            }
+            return true;
+        }
+    };
+
+    public static final IByteBufAdapter<BigInteger> BIG_INT = new IByteBufAdapter<>() {
+        @Override
+        public BigInteger deserialize(PacketBuffer buffer) throws IOException {
+            return new BigInteger(buffer.readByteArray());
+        }
+
+        @Override
+        public void serialize(PacketBuffer buffer, BigInteger u) throws IOException {
+            buffer.writeBytes(u.toByteArray());
+        }
+
+        @Override
+        public boolean areEqual(@NotNull BigInteger t1, @NotNull BigInteger t2) {
+            return t1.equals(t2);
+        }
+    };
+
+    public static final IByteBufAdapter<BigDecimal> BIG_DECIMAL = new IByteBufAdapter<>() {
+        @Override
+        public BigDecimal deserialize(PacketBuffer buffer) throws IOException {
+            return new BigDecimal(new BigInteger(buffer.readByteArray()), buffer.readVarInt());
+        }
+
+        @Override
+        public void serialize(PacketBuffer buffer, BigDecimal u) throws IOException {
+            buffer.writeBytes(u.unscaledValue().toByteArray());
+            buffer.writeVarInt(u.scale());
+        }
+
+        @Override
+        public boolean areEqual(@NotNull BigDecimal t1, @NotNull BigDecimal t2) {
+            return t1.equals(t2);
+        }
+    };
+
     public static <T> IByteBufAdapter<T> makeAdapter(@NotNull IByteBufDeserializer<T> deserializer, @NotNull IByteBufSerializer<T> serializer, @Nullable IEquals<T> comparator) {
         final IEquals<T> tester = comparator != null ? comparator : IEquals.defaultTester();
-        return new IByteBufAdapter<T>() {
+        return new IByteBufAdapter<>() {
             @Override
             public T deserialize(PacketBuffer buffer) throws IOException {
                 return deserializer.deserialize(buffer);

src/main/java/com/cleanroommc/modularui/value/sync/BigDecimalSyncValue.java

@@ -0,0 +1,18 @@
+package com.cleanroommc.modularui.value.sync;
+
+import com.cleanroommc.modularui.utils.serialization.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class BigDecimalSyncValue extends GenericSyncValue<BigDecimal> {
+
+    public BigDecimalSyncValue(@NotNull Supplier<BigDecimal> getter, @Nullable Consumer<BigDecimal> setter) {
+        super(getter, setter, ByteBufAdapters.BIG_DECIMAL, v -> new BigDecimal(v.unscaledValue(), v.scale()));
+    }
+}

src/main/java/com/cleanroommc/modularui/value/sync/BigIntSyncValue.java

@@ -0,0 +1,17 @@
+package com.cleanroommc.modularui.value.sync;
+
+import com.cleanroommc.modularui.utils.serialization.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.math.BigInteger;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class BigIntSyncValue extends GenericSyncValue<BigInteger> {
+
+    public BigIntSyncValue(@NotNull Supplier<BigInteger> getter, @Nullable Consumer<BigInteger> setter) {
+        super(getter, setter, ByteBufAdapters.BIG_INT, v -> new BigInteger(v.toByteArray()));
+    }
+}

src/main/java/com/cleanroommc/modularui/value/sync/ByteArraySyncValue.java

@@ -0,0 +1,16 @@
+package com.cleanroommc.modularui.value.sync;
+
+import com.cleanroommc.modularui.utils.serialization.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class ByteArraySyncValue extends GenericSyncValue<byte[]> {
+
+    public ByteArraySyncValue(@NotNull Supplier<byte[]> getter, @Nullable Consumer<byte[]> setter) {
+        super(getter, setter, ByteBufAdapters.BYTE_ARR, byte[]::clone);
+    }
+}

src/main/java/com/cleanroommc/modularui/value/sync/LongArraySyncValue.java

@@ -0,0 +1,16 @@
+package com.cleanroommc.modularui.value.sync;
+
+import com.cleanroommc.modularui.utils.serialization.ByteBufAdapters;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class LongArraySyncValue extends GenericSyncValue<long[]> {
+
+    public LongArraySyncValue(@NotNull Supplier<long[]> getter, @Nullable Consumer<long[]> setter) {
+        super(getter, setter, ByteBufAdapters.LONG_ARR, long[]::clone);
+    }
+}