Improve Sync Values

src/main/java/com/cleanroommc/modularui/api/value/IByteValue.java

@@ -0,0 +1,27 @@
+package com.cleanroommc.modularui.api.value;
+
+public interface IByteValue<T> extends IIntValue<T>, IStringValue<T> {
+
+    @Override
+    default void setIntValue(int val) {
+        setByteValue((byte) val);
+    }
+
+    @Override
+    default void setStringValue(String val) {
+        setByteValue(Byte.parseByte(val));
+    }
+
+    @Override
+    default int getIntValue() {
+        return getByteValue();
+    }
+
+    @Override
+    default String getStringValue() {
+        return String.valueOf(getByteValue());
+    }
+
+    void setByteValue(byte b);
+    byte getByteValue();
+}

src/main/java/com/cleanroommc/modularui/api/value/sync/IByteSyncValue.java

@@ -0,0 +1,17 @@
+package com.cleanroommc.modularui.api.value.sync;
+
+import com.cleanroommc.modularui.api.value.IByteValue;
+
+public interface IByteSyncValue<T> extends IByteValue<T>, IValueSyncHandler<T> {
+
+    @Override
+    default void setByteValue(byte val) {
+        setByteValue(val, true);
+    }
+
+    default void setByteValue(byte val, boolean setSource) {
+        setByteValue(val, setSource, true);
+    }
+
+    void setByteValue(byte value, boolean setSource, boolean sync);
+}

src/main/java/com/cleanroommc/modularui/value/ByteValue.java

@@ -0,0 +1,56 @@
+package com.cleanroommc.modularui.value;
+
+import com.cleanroommc.modularui.api.value.IByteValue;
+
+public class ByteValue implements IByteValue<Byte> {
+
+    protected byte value;
+
+    @Override
+    public void setByteValue(byte b) {
+        value = b;
+    }
+
+    @Override
+    public byte getByteValue() {
+        return value;
+    }
+
+    @Override
+    public Byte getValue() {
+        return getByteValue();
+    }
+
+    @Override
+    public void setValue(Byte value) {
+        setByteValue(value);
+    }
+
+    public static class Dynamic extends ByteValue {
+
+        private Supplier getter;
+        private Consumer setter;
+
+        public Dynamic(Supplier getter, Consumer setter) {
+            this.getter = getter;
+            this.setter = setter;
+        }
+
+        @Override
+        public void setByteValue(byte b) {
+            this.setter.setByte(b);
+        }
+
+        @Override
+        public byte getByteValue() {
+            return this.getter.getByte();
+        }
+    }
+
+    public interface Supplier {
+        byte getByte();
+    }
+    public interface Consumer {
+        void setByte(byte b);
+    }
+}

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

@@ -2,6 +2,8 @@
 
 import com.cleanroommc.modularui.api.value.sync.IBoolSyncValue;
 
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.function.Consumer;
@@ -12,20 +14,34 @@
  */
 public class BinaryEnumSyncValue<T extends Enum<T>> extends EnumSyncValue<T> implements IBoolSyncValue<T> {
 
-    public BinaryEnumSyncValue(Class<T> enumClass, Supplier<T> getter, Consumer<T> setter) {
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter, @Nullable Consumer<T> setter) {
         super(enumClass, getter, setter);
         if (enumClass.getEnumConstants().length != 2) {
             throw new IllegalArgumentException("Enum class must have exactly two elements");
         }
     }
 
-    public BinaryEnumSyncValue(Class<T> enumClass, @Nullable Supplier<T> clientGetter, @Nullable Consumer<T> clientSetter, @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter) {
+        this(enumClass, getter, (Consumer<T>) null);
+    }
+
+    @Contract("_, null, _, null, _ -> fail")
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass,
+                               @Nullable Supplier<T> clientGetter, @Nullable Consumer<T> clientSetter,
+                               @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {
         super(enumClass, clientGetter, clientSetter, serverGetter, serverSetter);
         if (enumClass.getEnumConstants().length != 2) {
             throw new IllegalArgumentException("Enum class must have exactly two elements");
         }
     }
 
+    @Contract("_, null, null -> fail")
+    public BinaryEnumSyncValue(@NotNull Class<T> enumClass,
+                               @Nullable Supplier<T> clientGetter,
+                               @Nullable Supplier<T> serverGetter) {
+        this(enumClass, clientGetter, null, serverGetter, null);
+    }
+
     @Override
     public boolean getBoolValue() {
         return this.cache.ordinal() == 1;

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

@@ -11,6 +11,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Objects;
 import java.util.function.BooleanSupplier;
 
 public class BooleanSyncValue extends ValueSyncHandler<Boolean> implements IBoolSyncValue<Boolean>, IStringSyncValue<Boolean> {
@@ -20,11 +21,21 @@ public class BooleanSyncValue extends ValueSyncHandler<Boolean> implements IBool
     private boolean cache;
 
     public BooleanSyncValue(@NotNull BooleanSupplier getter, @Nullable BooleanConsumer setter) {
-        this.getter = getter;
+        this.getter = Objects.requireNonNull(getter);
         this.setter = setter;
         this.cache = getter.getAsBoolean();
     }
 
+    public BooleanSyncValue(@NotNull BooleanSupplier getter) {
+        this(getter, (BooleanConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public BooleanSyncValue(@Nullable BooleanSupplier clientGetter,
+                            @Nullable BooleanSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
     @Contract("null, _, null, _ -> fail")
     public BooleanSyncValue(@Nullable BooleanSupplier clientGetter, @Nullable BooleanConsumer clientSetter,
                             @Nullable BooleanSupplier serverGetter, @Nullable BooleanConsumer serverSetter) {

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

@@ -0,0 +1,99 @@
+package com.cleanroommc.modularui.value.sync;
+
+import com.cleanroommc.modularui.api.value.sync.IByteSyncValue;
+
+import com.cleanroommc.modularui.network.NetworkUtils;
+
+import com.cleanroommc.modularui.value.ByteValue;
+
+import net.minecraft.network.PacketBuffer;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class ByteSyncValue extends ValueSyncHandler<Byte> implements IByteSyncValue<Byte> {
+
+    private byte cache;
+    private final ByteValue.Supplier getter;
+    private final ByteValue.Consumer setter;
+
+    public ByteSyncValue(@NotNull ByteValue.Supplier getter) {
+        this(getter, (ByteValue.Consumer) null);
+    }
+
+    public ByteSyncValue(@NotNull ByteValue.Supplier getter, @Nullable ByteValue.Consumer setter) {
+        this.getter = Objects.requireNonNull(getter);
+        this.setter = setter;
+        this.cache = getter.getByte();
+    }
+
+    @Contract("null, _, null, _ -> fail")
+    public ByteSyncValue(@Nullable ByteValue.Supplier clientGetter, @Nullable ByteValue.Consumer clientSetter,
+                         @Nullable ByteValue.Supplier serverGetter, @Nullable ByteValue.Consumer serverSetter) {
+        if (clientGetter == null && serverGetter == null) {
+            throw new NullPointerException("Client or server getter must not be null!");
+        }
+        if (NetworkUtils.isClient()) {
+            this.getter = clientGetter != null ? clientGetter : serverGetter;
+            this.setter = clientSetter != null ? clientSetter : serverSetter;
+        } else {
+            this.getter = serverGetter != null ? serverGetter : clientGetter;
+            this.setter = serverSetter != null ? serverSetter : clientSetter;
+        }
+        this.cache = this.getter.getByte();
+    }
+
+    public ByteSyncValue(@Nullable ByteValue.Supplier clientGetter,
+                         @Nullable ByteValue.Supplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
+    @Override
+    public void setValue(Byte value, boolean setSource, boolean sync) {
+        setByteValue(value, setSource, sync);
+    }
+
+    @Override
+    public boolean updateCacheFromSource(boolean isFirstSync) {
+        if (isFirstSync || this.getter.getByte() != this.cache) {
+            setByteValue(this.getter.getByte(), false, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void write(PacketBuffer buffer) throws IOException {
+        buffer.writeByte(getByteValue());
+    }
+
+    @Override
+    public void read(PacketBuffer buffer) throws IOException {
+        setByteValue(buffer.readByte(), false, false);
+    }
+
+    @Override
+    public Byte getValue() {
+        return getByteValue();
+    }
+
+    @Override
+    public void setByteValue(byte value, boolean setSource, boolean sync) {
+        this.cache = value;
+        if (setSource && this.setter != null) {
+            this.setter.setByte(value);
+        }
+        if (sync) {
+            sync(0, this::write);
+        }
+    }
+
+    @Override
+    public byte getByteValue() {
+        return this.cache;
+    }
+}

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

@@ -10,6 +10,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Objects;
 import java.util.function.DoubleConsumer;
 import java.util.function.DoubleSupplier;
 
@@ -19,12 +20,22 @@ public class DoubleSyncValue extends ValueSyncHandler<Double> implements IDouble
     private final DoubleConsumer setter;
     private double cache;
 
-    public DoubleSyncValue(DoubleSupplier getter, DoubleConsumer setter) {
-        this.getter = getter;
+    public DoubleSyncValue(@NotNull DoubleSupplier getter, @Nullable DoubleConsumer setter) {
+        this.getter = Objects.requireNonNull(getter);
         this.setter = setter;
         this.cache = getter.getAsDouble();
     }
 
+    public DoubleSyncValue(@NotNull DoubleSupplier getter) {
+        this(getter, (DoubleConsumer) null);
+    }
+
+    @Contract("null, null -> fail")
+    public DoubleSyncValue(@Nullable DoubleSupplier clientGetter,
+                           @Nullable DoubleSupplier serverGetter) {
+        this(clientGetter, null, serverGetter, null);
+    }
+
     @Contract("null, _, null, _ -> fail")
     public DoubleSyncValue(@Nullable DoubleSupplier clientGetter, @Nullable DoubleConsumer clientSetter,
                            @Nullable DoubleSupplier serverGetter, @Nullable DoubleConsumer serverSetter) {

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

@@ -7,8 +7,10 @@
 import net.minecraft.network.PacketBuffer;
 
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
@@ -19,13 +21,24 @@ public class EnumSyncValue<T extends Enum<T>> extends ValueSyncHandler<T> implem
     private final Consumer<T> setter;
     protected T cache;
 
-    public EnumSyncValue(Class<T> enumClass, Supplier<T> getter, Consumer<T> setter) {
-        this.enumClass = enumClass;
-        this.getter = getter;
+    public EnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter, @Nullable Consumer<T> setter) {
+        this.enumClass = Objects.requireNonNull(enumClass);
+        this.getter = Objects.requireNonNull(getter);
         this.setter = setter;
         this.cache = getter.get();
     }
 
+    public EnumSyncValue(@NotNull Class<T> enumClass, @NotNull Supplier<T> getter) {
+        this(enumClass, getter, (Consumer<T>) null);
+    }
+
+    @Contract("_, null, null -> fail")
+    public EnumSyncValue(Class<T> enumClass,
+                         @Nullable Supplier<T> clientGetter,
+                         @Nullable Supplier<T> serverGetter) {
+        this(enumClass, clientGetter, null, serverGetter, null);
+    }
+
     @Contract("_, null, _, null, _ -> fail")
     public EnumSyncValue(Class<T> enumClass, @Nullable Supplier<T> clientGetter, @Nullable Consumer<T> clientSetter,
                          @Nullable Supplier<T> serverGetter, @Nullable Consumer<T> serverSetter) {

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

@@ -40,12 +40,24 @@ public GenericListSyncHandler(@NotNull Supplier<List<T>> getter,
         this(getter, setter, deserializer, serializer, null);
     }
 
+    public GenericListSyncHandler(@NotNull Supplier<List<T>> getter,
+                                  @NotNull IByteBufAdapter<T> adapter) {
+        this(getter, null, adapter, adapter, adapter);
+    }
+
+    public GenericListSyncHandler(@NotNull Supplier<List<T>> getter,
+                                  @NotNull IByteBufDeserializer<T> deserializer,
+                                  @NotNull IByteBufSerializer<T> serializer) {
+        this(getter, null, deserializer, serializer, null);
+    }
+
     public GenericListSyncHandler(@NotNull Supplier<List<T>> getter,
                                   @Nullable Consumer<List<T>> setter,
                                   @NotNull IByteBufDeserializer<T> deserializer,
                                   @NotNull IByteBufSerializer<T> serializer,
                                   @Nullable IEquals<T> equals) {
-        this.getter = getter;
+        this.getter = Objects.requireNonNull(getter);
+        this.cache.addAll(getter.get());
         this.setter = setter;
         this.deserializer = deserializer;
         this.serializer = serializer;