refactor: serializer helper instead of ByteBuffer wrapper + added serviceId to config

bridge-common/src/main/java/com/luminiadev/bridge/network/AbstractBridgeNetwork.java

@@ -2,13 +2,15 @@
 
 import com.luminiadev.bridge.exception.BridgeCodecException;
 import com.luminiadev.bridge.network.codec.BridgeCodec;
-import com.luminiadev.bridge.network.codec.packet.handler.BridgePacketHandler;
 import com.luminiadev.bridge.network.codec.packet.BridgePacket;
-import com.luminiadev.bridge.util.ByteBuffer;
+import com.luminiadev.bridge.network.codec.packet.handler.BridgePacketHandler;
+import io.netty.buffer.ByteBuf;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnmodifiableView;
 
-import java.util.*;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 public abstract class AbstractBridgeNetwork implements BridgeNetwork {
 
@@ -41,15 +43,15 @@ public void removePacketHandler(BridgePacketHandler handler) {
     }
 
     @Override
-    public BridgePacket tryDecode(ByteBuffer buffer, String packetId) {
+    public BridgePacket tryDecode(ByteBuf buffer, String packetId) {
         if (codec == null) {
             throw new BridgeCodecException("Codec is not set");
         }
         return codec.tryDecode(buffer, packetId);
     }
 
     @Override
-    public <T extends BridgePacket> void tryEncode(ByteBuffer buffer, T packet) {
+    public <T extends BridgePacket> void tryEncode(ByteBuf buffer, T packet) {
         if (codec == null) {
             throw new BridgeCodecException("Codec is not set");
         }

bridge-common/src/main/java/com/luminiadev/bridge/network/BridgeNetwork.java

@@ -1,9 +1,9 @@
 package com.luminiadev.bridge.network;
 
 import com.luminiadev.bridge.network.codec.BridgeCodec;
-import com.luminiadev.bridge.network.codec.packet.handler.BridgePacketHandler;
 import com.luminiadev.bridge.network.codec.packet.BridgePacket;
-import com.luminiadev.bridge.util.ByteBuffer;
+import com.luminiadev.bridge.network.codec.packet.handler.BridgePacketHandler;
+import io.netty.buffer.ByteBuf;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnmodifiableView;
 
@@ -25,9 +25,9 @@ public interface BridgeNetwork {
 
     <T extends BridgePacket> void sendPacket(T packet);
 
-    BridgePacket tryDecode(ByteBuffer buffer, String packetId);
+    BridgePacket tryDecode(ByteBuf buffer, String packetId);
 
-    <T extends BridgePacket> void tryEncode(ByteBuffer buffer, T packet);
+    <T extends BridgePacket> void tryEncode(ByteBuf buffer, T packet);
 
     void start();
 

bridge-common/src/main/java/com/luminiadev/bridge/network/codec/BridgeCodec.java

@@ -6,7 +6,8 @@
 import com.luminiadev.bridge.network.codec.packet.BridgePacketFactory;
 import com.luminiadev.bridge.network.codec.packet.BridgeUnknownPacket;
 import com.luminiadev.bridge.network.codec.packet.serializer.BridgePacketSerializer;
-import com.luminiadev.bridge.util.ByteBuffer;
+import com.luminiadev.bridge.network.codec.packet.serializer.BridgePacketSerializerHelper;
+import io.netty.buffer.ByteBuf;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.HashMap;
@@ -49,8 +50,9 @@ public void unregisterPacket(String packetId) {
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    public BridgePacket tryDecode(ByteBuffer buffer, String packetId) {
+    public BridgePacket tryDecode(ByteBuf buffer, String packetId) {
         BridgePacketDefinition<? extends BridgePacket> definition = this.getPacketDefinition(packetId);
+        BridgePacketSerializerHelper helper = new BridgePacketSerializerHelper(buffer);
 
         BridgePacket packet;
         BridgePacketSerializer<BridgePacket> serializer;
@@ -65,12 +67,14 @@ public BridgePacket tryDecode(ByteBuffer buffer, String packetId) {
             serializer = (BridgePacketSerializer) new BridgeUnknownPacket.BridgeUnknownPacketSerializer();
         }
 
-        serializer.deserialize(buffer, packet);
+        serializer.deserialize(buffer, helper, packet);
         return packet;
     }
 
     @SuppressWarnings("unchecked")
-    public <T extends BridgePacket> void tryEncode(ByteBuffer buffer, T packet) {
+    public <T extends BridgePacket> void tryEncode(ByteBuf buffer, T packet) {
+        BridgePacketSerializerHelper helper = new BridgePacketSerializerHelper(buffer);
+
         BridgePacketSerializer<T> serializer;
         if (packet instanceof BridgeUnknownPacket) {
             serializer = (BridgePacketSerializer<T>) new BridgeUnknownPacket.BridgeUnknownPacketSerializer();
@@ -81,7 +85,8 @@ public <T extends BridgePacket> void tryEncode(ByteBuffer buffer, T packet) {
             }
             serializer = definition.getSerializer();
         }
-        serializer.serialize(buffer, packet);
+
+        serializer.serialize(buffer, helper, packet);
     }
 
     public Builder toBuilder() {

bridge-common/src/main/java/com/luminiadev/bridge/network/codec/packet/BridgeUnknownPacket.java

@@ -1,17 +1,18 @@
 package com.luminiadev.bridge.network.codec.packet;
 
 import com.luminiadev.bridge.network.codec.packet.serializer.BridgePacketSerializer;
-import com.luminiadev.bridge.util.ByteBuffer;
-import org.jetbrains.annotations.NotNull;
+import com.luminiadev.bridge.network.codec.packet.serializer.BridgePacketSerializerHelper;
+import io.netty.buffer.ByteBuf;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import org.jetbrains.annotations.NotNull;
 
 @Data
 @EqualsAndHashCode(doNotUseGetters = true)
 public final class BridgeUnknownPacket implements BridgePacket {
 
     private String originalId;
-    private ByteBuffer originalPayload;
+    private ByteBuf originalPayload;
 
     @Override
     public @NotNull String getId() {
@@ -21,19 +22,15 @@ public final class BridgeUnknownPacket implements BridgePacket {
     public static final class BridgeUnknownPacketSerializer implements BridgePacketSerializer<BridgeUnknownPacket> {
 
         @Override
-        public void serialize(ByteBuffer buffer, BridgeUnknownPacket packet) {
-            buffer.writeString(packet.getOriginalId());
-            buffer.writeBytes(
-                    packet.getOriginalPayload().byteBuf(),
-                    packet.getOriginalPayload().readerIndex(),
-                    packet.getOriginalPayload().readableBytes()
-            );
+        public void serialize(ByteBuf buffer, BridgePacketSerializerHelper helper, BridgeUnknownPacket packet) {
+            helper.writeString(packet.originalId);
+            buffer.writeBytes(packet.originalPayload, packet.originalPayload.readerIndex(), packet.originalPayload.readableBytes());
         }
 
         @Override
-        public void deserialize(ByteBuffer buffer, BridgeUnknownPacket packet) {
-            packet.setOriginalId(buffer.readString());
-            packet.setOriginalPayload(ByteBuffer.of(buffer.readRetainedSlice(buffer.readableBytes())));
+        public void deserialize(ByteBuf buffer, BridgePacketSerializerHelper helper, BridgeUnknownPacket packet) {
+            packet.setOriginalId(helper.readString());
+            packet.setOriginalPayload(buffer.readRetainedSlice(buffer.readableBytes()));
         }
     }
 }

bridge-common/src/main/java/com/luminiadev/bridge/network/codec/packet/serializer/BridgePacketSerializer.java

@@ -1,11 +1,11 @@
 package com.luminiadev.bridge.network.codec.packet.serializer;
 
 import com.luminiadev.bridge.network.codec.packet.BridgePacket;
-import com.luminiadev.bridge.util.ByteBuffer;
+import io.netty.buffer.ByteBuf;
 
 public interface BridgePacketSerializer<T extends BridgePacket> {
 
-    void serialize(ByteBuffer buffer, T packet);
+    void serialize(ByteBuf buffer, BridgePacketSerializerHelper helper, T packet);
 
-    void deserialize(ByteBuffer buffer, T packet);
+    void deserialize(ByteBuf buffer, BridgePacketSerializerHelper helper, T packet);
 }

bridge-common/src/main/java/com/luminiadev/bridge/network/codec/packet/serializer/BridgePacketSerializerHelper.java

@@ -0,0 +1,117 @@
+package com.luminiadev.bridge.network.codec.packet.serializer;
+
+import com.luminiadev.bridge.util.VarInts;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import lombok.AllArgsConstructor;
+
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.ObjIntConsumer;
+import java.util.function.ToLongFunction;
+
+@AllArgsConstructor
+public final class BridgePacketSerializerHelper {
+
+    private final ByteBuf buffer;
+
+    public String readString() {
+        int length = this.readUnsignedVarInt();
+        return (String) buffer.readCharSequence(length, StandardCharsets.UTF_8);
+    }
+
+    public void writeString(String string) {
+        this.writeUnsignedVarInt(ByteBufUtil.utf8Bytes(string));
+        buffer.writeCharSequence(string, StandardCharsets.UTF_8);
+    }
+
+    public UUID readUuid() {
+        return new UUID(buffer.readLongLE(), buffer.readLongLE());
+    }
+
+    public void writeUuid(UUID uuid) {
+        buffer.writeLongLE(uuid.getMostSignificantBits());
+        buffer.writeLongLE(uuid.getLeastSignificantBits());
+    }
+
+    public <T> T[] readArray(T[] array, Function<ByteBuf, T> function) {
+        List<T> list = new ArrayList<>();
+        readArray(list, function);
+        return list.toArray(array);
+    }
+
+    public <T> void readArray(Collection<T> array, Function<ByteBuf, T> function) {
+        this.readArray(array, VarInts::readUnsignedInt, function);
+    }
+
+    public <T> void readArray(Collection<T> array, ToLongFunction<ByteBuf> lengthReader, Function<ByteBuf, T> function) {
+        long length = lengthReader.applyAsLong(buffer);
+        for (int i = 0; i < length; i++) {
+            array.add(function.apply(buffer));
+        }
+    }
+
+    public <T> void writeArray(Collection<T> array, BiConsumer<ByteBuf, T> consumer) {
+        this.writeArray(array, VarInts::writeUnsignedInt, consumer);
+    }
+
+    public <T> void writeArray(Collection<T> array, ObjIntConsumer<ByteBuf> lengthWriter, BiConsumer<ByteBuf, T> consumer) {
+        lengthWriter.accept(buffer, array.size());
+        for (T val : array) {
+            consumer.accept(buffer, val);
+        }
+    }
+
+    public <T> void writeArray(T[] array, BiConsumer<ByteBuf, T> consumer) {
+        VarInts.writeUnsignedInt(buffer, array.length);
+        for (T val : array) {
+            consumer.accept(buffer, val);
+        }
+    }
+
+    public void writeUnsignedVarInt(int value) {
+        VarInts.writeUnsignedInt(buffer, value);
+    }
+
+    public int readUnsignedVarInt() {
+        return VarInts.readUnsignedInt(buffer);
+    }
+
+    public void writeVarInt(int value) {
+        VarInts.writeInt(buffer, value);
+    }
+
+    public int readVarInt() {
+        return VarInts.readInt(buffer);
+    }
+
+    public void writeUnsignedVarLong(long value) {
+        VarInts.writeUnsignedLong(buffer, value);
+    }
+
+    public long readUnsignedVarLong() {
+        return VarInts.readUnsignedLong(buffer);
+    }
+
+    public void writeUnsignedBigVarInt(BigInteger value) {
+        VarInts.writeUnsignedBigVarInt(buffer, value);
+    }
+
+    public BigInteger readUnsignedBigVarInt(int length) {
+        return VarInts.readUnsignedBigVarInt(buffer, length);
+    }
+
+    public void writeVarLong(long value) {
+        VarInts.writeLong(buffer, value);
+    }
+
+    public long readVarLong() {
+        return VarInts.readLong(buffer);
+    }
+}