From a49cfbb902a3c9462387beacd500970fcb2f77b1 Mon Sep 17 00:00:00 2001 From: jaysunxiao Date: Sun, 17 Oct 2021 18:17:41 +0800 Subject: [PATCH] =?UTF-8?q?ref[protocol]:=20=E9=87=8D=E6=9E=84protocol?= =?UTF-8?q?=E7=9A=84JavaScript=E7=9A=84=E8=A7=A3=E6=9E=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../zfoo/protocol/buffer/ByteBufUtils.java | 193 ++- .../serializer/CutDownArraySerializer.java | 275 ++++- .../serializer/CutDownListSerializer.java | 226 +++- .../serializer/CutDownMapSerializer.java | 245 +++- .../serializer/CutDownSetSerializer.java | 225 +++- .../serializer/js/GenerateJsUtils.java | 22 +- .../serializer/js/JsArraySerializer.java | 15 +- .../serializer/js/JsListSerializer.java | 15 +- .../serializer/js/JsMapSerializer.java | 16 +- .../js/JsObjectProtocolSerializer.java | 4 +- .../serializer/js/JsSetSerializer.java | 15 +- .../src/main/resources/js/ProtocolManager.js | 4 +- .../main/resources/js/buffer/ByteBuffer.js | 610 +++++++++- .../java/com/zfoo/protocol/SpeedTest.java | 7 +- .../zfoo/protocol/packet/ComplexObject.java | 2 +- .../zfoo/protocol/packet/NormalObject.java | 2 +- .../com/zfoo/protocol/packet/ObjectA.java | 2 +- .../com/zfoo/protocol/packet/ObjectB.java | 2 +- .../zfoo/protocol/packet/SimpleObject.java | 2 +- .../src/test/resources/ComplexObject.bytes | Bin 2214 -> 2214 bytes .../jsTest/jsProtocol/ProtocolManager.js | 18 +- .../jsTest/jsProtocol/buffer/ByteBuffer.js | 610 +++++++++- .../jsTest/jsProtocol/packet/ComplexObject.js | 1044 +++++------------ .../jsTest/jsProtocol/packet/NormalObject.js | 374 +----- .../jsTest/jsProtocol/packet/ObjectA.js | 50 +- .../jsTest/jsProtocol/packet/ObjectB.js | 19 +- .../jsTest/jsProtocol/packet/SimpleObject.js | 19 +- .../resources/jsTest/jsProtocolTest.spec.js | 10 +- 28 files changed, 2606 insertions(+), 1420 deletions(-) diff --git a/protocol/src/main/java/com/zfoo/protocol/buffer/ByteBufUtils.java b/protocol/src/main/java/com/zfoo/protocol/buffer/ByteBufUtils.java index 160b1b91..5ea19802 100644 --- a/protocol/src/main/java/com/zfoo/protocol/buffer/ByteBufUtils.java +++ b/protocol/src/main/java/com/zfoo/protocol/buffer/ByteBufUtils.java @@ -726,6 +726,42 @@ public abstract class ByteBufUtils { return array; } + public static void writeBooleanCollection(ByteBuf byteBuf, Collection collection) { + if (collection == null) { + byteBuf.writeByte(0); + return; + } + writeInt(byteBuf, collection.size()); + for (var value : collection) { + writeBooleanBox(byteBuf, value); + } + } + + public static void writeBooleanList(ByteBuf byteBuf, List list) { + writeBooleanCollection(byteBuf, list); + } + + public static List readBooleanList(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var list = (List) CollectionUtils.newFixedList(length); + for (var i = 0; i < length; i++) { + list.add(readBooleanBox(byteBuf)); + } + return list; + } + + public static void writeBooleanSet(ByteBuf byteBuf, Set set) { + writeBooleanCollection(byteBuf, set); + } + + public static Set readBooleanSet(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var set = (Set) CollectionUtils.newFixedSet(length); + for (var i = 0; i < length; i++) { + set.add(readBooleanBox(byteBuf)); + } + return set; + } //---------------------------------byte-------------------------------------- public static void writeByteArray(ByteBuf byteBuf, byte[] array) { @@ -768,6 +804,42 @@ public abstract class ByteBufUtils { return bytesBox; } + public static void writeByteCollection(ByteBuf byteBuf, Collection collection) { + if (collection == null) { + byteBuf.writeByte(0); + return; + } + writeInt(byteBuf, collection.size()); + for (var value : collection) { + writeByteBox(byteBuf, value); + } + } + + public static void writeByteList(ByteBuf byteBuf, List list) { + writeByteCollection(byteBuf, list); + } + + public static List readByteList(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var list = (List) CollectionUtils.newFixedList(length); + for (var i = 0; i < length; i++) { + list.add(readByteBox(byteBuf)); + } + return list; + } + + public static void writeByteSet(ByteBuf byteBuf, Set set) { + writeByteCollection(byteBuf, set); + } + + public static Set readByteSet(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var set = (Set) CollectionUtils.newFixedSet(length); + for (var i = 0; i < length; i++) { + set.add(readByteBox(byteBuf)); + } + return set; + } //---------------------------------short-------------------------------------- public static void writeShortArray(ByteBuf byteBuf, short[] array) { @@ -818,6 +890,43 @@ public abstract class ByteBufUtils { return shorts; } + public static void writeShortCollection(ByteBuf byteBuf, Collection collection) { + if (collection == null) { + byteBuf.writeByte(0); + return; + } + writeInt(byteBuf, collection.size()); + for (var value : collection) { + writeShortBox(byteBuf, value); + } + } + + public static void writeShortList(ByteBuf byteBuf, List list) { + writeShortCollection(byteBuf, list); + } + + public static List readShortList(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var list = (List) CollectionUtils.newFixedList(length); + for (var i = 0; i < length; i++) { + list.add(readShortBox(byteBuf)); + } + return list; + } + + public static void writeShortSet(ByteBuf byteBuf, Set set) { + writeShortCollection(byteBuf, set); + } + + public static Set readShortSet(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var set = (Set) CollectionUtils.newFixedSet(length); + for (var i = 0; i < length; i++) { + set.add(readShortBox(byteBuf)); + } + return set; + } + //---------------------------------int-------------------------------------- public static void writeIntArray(ByteBuf byteBuf, int[] array) { @@ -890,11 +999,11 @@ public abstract class ByteBufUtils { public static Set readIntSet(ByteBuf byteBuf) { var length = readInt(byteBuf); - var list = (Set) CollectionUtils.newFixedSet(length); + var set = (Set) CollectionUtils.newFixedSet(length); for (var i = 0; i < length; i++) { - list.add(readIntBox(byteBuf)); + set.add(readIntBox(byteBuf)); } - return list; + return set; } @@ -1025,6 +1134,42 @@ public abstract class ByteBufUtils { return floats; } + public static void writeFloatCollection(ByteBuf byteBuf, Collection collection) { + if (collection == null) { + byteBuf.writeByte(0); + return; + } + writeInt(byteBuf, collection.size()); + for (var value : collection) { + writeFloatBox(byteBuf, value); + } + } + + public static void writeFloatList(ByteBuf byteBuf, List list) { + writeFloatCollection(byteBuf, list); + } + + public static List readFloatList(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var list = (List) CollectionUtils.newFixedList(length); + for (var i = 0; i < length; i++) { + list.add(readFloatBox(byteBuf)); + } + return list; + } + + public static void writeFloatSet(ByteBuf byteBuf, Set set) { + writeFloatCollection(byteBuf, set); + } + + public static Set readFloatSet(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var set = (Set) CollectionUtils.newFixedSet(length); + for (var i = 0; i < length; i++) { + set.add(readFloatBox(byteBuf)); + } + return set; + } //---------------------------------double-------------------------------------- public static void writeDoubleArray(ByteBuf byteBuf, double[] array) { @@ -1075,6 +1220,42 @@ public abstract class ByteBufUtils { return doubles; } + public static void writeDoubleCollection(ByteBuf byteBuf, Collection collection) { + if (collection == null) { + byteBuf.writeByte(0); + return; + } + writeInt(byteBuf, collection.size()); + for (var value : collection) { + writeDoubleBox(byteBuf, value); + } + } + + public static void writeDoubleList(ByteBuf byteBuf, List list) { + writeDoubleCollection(byteBuf, list); + } + + public static List readDoubleList(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var list = (List) CollectionUtils.newFixedList(length); + for (var i = 0; i < length; i++) { + list.add(readDoubleBox(byteBuf)); + } + return list; + } + + public static void writeDoubleSet(ByteBuf byteBuf, Set set) { + writeDoubleCollection(byteBuf, set); + } + + public static Set readDoubleSet(ByteBuf byteBuf) { + var length = readInt(byteBuf); + var set = (Set) CollectionUtils.newFixedSet(length); + for (var i = 0; i < length; i++) { + set.add(readDoubleBox(byteBuf)); + } + return set; + } //---------------------------------string-------------------------------------- public static void writeStringArray(ByteBuf byteBuf, String[] array) { @@ -1127,11 +1308,11 @@ public abstract class ByteBufUtils { public static Set readStringSet(ByteBuf byteBuf) { var length = readInt(byteBuf); - var list = (Set) CollectionUtils.newFixedSet(length); + var set = (Set) CollectionUtils.newFixedSet(length); for (var i = 0; i < length; i++) { - list.add(readString(byteBuf)); + set.add(readString(byteBuf)); } - return list; + return set; } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownArraySerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownArraySerializer.java index cf455048..f57693a4 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownArraySerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownArraySerializer.java @@ -21,6 +21,8 @@ import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; +import static com.zfoo.protocol.util.FileUtils.LS; + /** * @author jaysunxiao * @version 3.0 @@ -38,6 +40,7 @@ public class CutDownArraySerializer implements ICutDownSerializer { public boolean writeObject(StringBuilder builder, String objectStr, Field field, IFieldRegistration fieldRegistration, CodeLanguage language) { var arrayField = (ArrayField) fieldRegistration; var arrayName = getArrayClassName(arrayField); + var flag = true; // 直接在字节码里调用方法是为了减小生成字节码的体积，下面的代码去掉也不会有任何影响 switch (arrayName) { @@ -45,119 +48,204 @@ public class CutDownArraySerializer implements ICutDownSerializer { switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeBooleanArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeBooleanArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Boolean": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeBooleanBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeBooleanArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "byte": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeByteArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeByteArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Byte": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeByteBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeByteArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "short": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeShortArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeShortArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Short": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeShortBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeShortArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "int": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeIntArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Integer": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeIntBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "long": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeLongArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Long": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeLongBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "float": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeFloatArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeFloatArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Float": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeFloatBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeFloatArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "double": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeDoubleArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeDoubleArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Double": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeDoubleBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeDoubleArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "String": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeStringArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "char": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeCharArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeCharArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "Character": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeCharBoxArray($1, {});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeCharArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; default: @@ -166,12 +254,19 @@ public class CutDownArraySerializer implements ICutDownSerializer { switch (language) { case Enhance: builder.append(StringUtils.format("{}.writePacketArray($1, {}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writePacketArray({}, {});", objectStr, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; } + } else { + flag = false; } } - return false; + return flag; } @Override @@ -181,132 +276,234 @@ public class CutDownArraySerializer implements ICutDownSerializer { var array = "array" + GenerateProtocolFile.index.getAndIncrement(); + var flag = true; switch (arrayName) { case "boolean": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readBooleanArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readBooleanArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Boolean": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readBooleanBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readBooleanArray();", array)).append(LS); + break; + default: + flag = false; } break; case "byte": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readByteArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readByteArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Byte": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readByteBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readByteArray();", array)).append(LS); + break; + default: + flag = false; } break; case "short": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readShortArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readShortArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Short": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readShortBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readShortArray();", array)).append(LS); + break; + default: + flag = false; } break; case "int": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readIntArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Integer": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readIntBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntArray();", array)).append(LS); + break; + default: + flag = false; } break; case "long": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readLongArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Long": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readLongBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongArray();", array)).append(LS); + break; + default: + flag = false; } break; case "float": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readFloatArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readFloatArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Float": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readFloatBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readFloatArray();", array)).append(LS); + break; + default: + flag = false; } break; case "double": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readDoubleArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readDoubleArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Double": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readDoubleBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readDoubleArray();", array)).append(LS); + break; + default: + flag = false; } break; case "String": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readStringArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringArray();", array)).append(LS); + break; + default: + flag = false; } break; case "char": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readCharArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readCharArray();", array)).append(LS); + break; + default: + flag = false; } break; case "Character": switch (language) { case Enhance: builder.append(StringUtils.format("{}[] {} = {}.readCharBoxArray($1);", arrayName, array, EnhanceUtils.byteBufUtils)); - return array; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readCharArray();", array)).append(LS); + break; + default: + flag = false; } break; default: - // Java不支持泛型的数组初始化，这边就不做任何操作 + if (arrayField.getArrayElementRegistration() instanceof ObjectProtocolField) { + var objectProtocolField = (ObjectProtocolField) arrayField.getArrayElementRegistration(); + switch (language) { + // Java不支持泛型的数组初始化，这边就不做任何操作 + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readPacketArray({});", array, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; + } + } else { + flag = false; + } } - GenerateProtocolFile.index.getAndDecrement(); - return null; + if (flag) { + return array; + } else { + GenerateProtocolFile.index.getAndDecrement(); + return null; + } } public String getArrayClassName(ArrayField arrayField) { diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownListSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownListSerializer.java index df498b55..3dd52e06 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownListSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownListSerializer.java @@ -21,6 +21,8 @@ import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; +import static com.zfoo.protocol.util.FileUtils.LS; + /** * @author jaysunxiao * @version 3.0 @@ -36,20 +38,93 @@ public class CutDownListSerializer implements ICutDownSerializer { @Override public boolean writeObject(StringBuilder builder, String objectStr, Field field, IFieldRegistration fieldRegistration, CodeLanguage language) { var listField = (ListField) fieldRegistration; + var flag = true; switch (listField.getType().getTypeName()) { + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeBooleanList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeBooleanArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeByteList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeByteArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeShortList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeShortArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; case "java.util.List": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeIntList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "java.util.List": { switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeLongList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + } + case "java.util.List": { + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeFloatList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeFloatArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + } + case "java.util.List": { + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeDoubleList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeDoubleArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; } @@ -57,64 +132,163 @@ public class CutDownListSerializer implements ICutDownSerializer { switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeStringList($1, (List){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; default: + // List + if (listField.getListElementRegistration() instanceof ObjectProtocolField) { + var objectProtocolField = (ObjectProtocolField) listField.getListElementRegistration(); + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writePacketList($1, (List){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writePacketArray({}, {});", objectStr, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; + } + } else { + flag = false; + } } - // List - if (listField.getListElementRegistration() instanceof ObjectProtocolField) { - var objectProtocolField = (ObjectProtocolField) listField.getListElementRegistration(); - switch (language) { - case Enhance: - builder.append(StringUtils.format("{}.writePacketList($1, (List){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); - return true; - } - } - return false; + return flag; } @Override public String readObject(StringBuilder builder, Field field, IFieldRegistration fieldRegistration, CodeLanguage language) { var listField = (ListField) fieldRegistration; var list = "list" + GenerateProtocolFile.index.getAndIncrement(); + var flag = true; switch (listField.getType().getTypeName()) { + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readBooleanList($1);", list, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readBooleanArray();", list)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readByteList($1);", list, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readByteArray();", list)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readShortList($1);", list, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readShortArray();", list)).append(LS); + break; + default: + flag = false; + } + break; case "java.util.List": switch (language) { case Enhance: builder.append(StringUtils.format("List {} = {}.readIntList($1);", list, EnhanceUtils.byteBufUtils)); - return list; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntArray();", list)).append(LS); + break; + default: + flag = false; } break; case "java.util.List": switch (language) { case Enhance: builder.append(StringUtils.format("List {} = {}.readLongList($1);", list, EnhanceUtils.byteBufUtils)); - return list; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongArray();", list)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readFloatList($1);", list, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readFloatArray();", list)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.List": + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readDoubleList($1);", list, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readDoubleArray();", list)).append(LS); + break; + default: + flag = false; } break; case "java.util.List": switch (language) { case Enhance: builder.append(StringUtils.format("List {} = {}.readStringList($1);", list, EnhanceUtils.byteBufUtils)); - return list; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringArray();", list)).append(LS); + break; + default: + flag = false; } break; default: + if (listField.getListElementRegistration() instanceof ObjectProtocolField) { + var objectProtocolField = (ObjectProtocolField) listField.getListElementRegistration(); + switch (language) { + case Enhance: + builder.append(StringUtils.format("List {} = {}.readPacketList($1, {});", list, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readPacketArray({});", list, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; + } + } else { + flag = false; + } } - if (listField.getListElementRegistration() instanceof ObjectProtocolField) { - var objectProtocolField = (ObjectProtocolField) listField.getListElementRegistration(); - switch (language) { - case Enhance: - builder.append(StringUtils.format("List {} = {}.readPacketList($1, {});", list, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); - return list; - } - } - GenerateProtocolFile.index.getAndDecrement(); - return null; + if (flag) { + return list; + } else { + GenerateProtocolFile.index.getAndDecrement(); + return null; + } } } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownMapSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownMapSerializer.java index aa6c7b6a..ff85c3a0 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownMapSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownMapSerializer.java @@ -26,6 +26,8 @@ import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; +import static com.zfoo.protocol.util.FileUtils.LS; + /** * @author jaysunxiao * @version 3.0 @@ -50,50 +52,120 @@ public class CutDownMapSerializer implements ICutDownSerializer { if (keyRegistration instanceof BaseField) { if (keySerializer == IntSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeIntIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeIntIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntIntMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeIntLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeIntLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntLongMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeIntStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeIntStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntStringMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeIntPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeIntPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntPacketMap({}, {});", objectStr, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return true; + } } } else if (keySerializer == LongSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeLongIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeLongIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongIntMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeLongLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeLongLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongLongMap({}, {});", objectStr, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return true; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeLongStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeLongStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongStringMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeLongPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeLongPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongPacketMap({}, {});", objectStr, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return true; + } } - } else if (keySerializer == StringSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeStringIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeStringIntMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringIntMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeStringLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeStringLongMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringLongMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeStringStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeStringStringMap($1, (Map){});", EnhanceUtils.byteBufUtils, objectStr)); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringStringMap({});", objectStr)).append(LS); + return true; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("{}.writeStringPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return true; + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeStringPacketMap($1, (Map){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return true; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringPacketMap({}, {});", objectStr, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return true; + } } } } - return false; } @@ -110,49 +182,120 @@ public class CutDownMapSerializer implements ICutDownSerializer { if (keyRegistration instanceof BaseField) { if (keySerializer == IntSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readIntIntMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readIntIntMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntIntMap();", map)).append(LS); + return map; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readIntLongMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readIntLongMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntLongMap();", map)).append(LS); + return map; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readIntStringMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readIntStringMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntStringMap();", map)).append(LS); + return map; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readIntPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readIntPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntPacketMap({});", map, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return map; + } } } else if (keySerializer == LongSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readLongIntMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readLongIntMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongIntMap();", map)).append(LS); + return map; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readLongLongMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readLongLongMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongLongMap();", map)).append(LS); + return map; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readLongStringMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readLongStringMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongStringMap();", map)).append(LS); + return map; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readLongPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readLongPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongPacketMap({});", map, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return map; + } } } else if (keySerializer == StringSerializer.INSTANCE) { if (valueSerializer == IntSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readStringIntMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readStringIntMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringIntMap();", map)).append(LS); + return map; + } } else if (valueSerializer == LongSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readStringLongMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readStringLongMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringLongMap();", map)).append(LS); + return map; + } } else if (valueSerializer == StringSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readStringStringMap($1);", map, EnhanceUtils.byteBufUtils)); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readStringStringMap($1);", map, EnhanceUtils.byteBufUtils)); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringStringMap();", map)).append(LS); + return map; + } } else if (valueSerializer == ObjectProtocolSerializer.INSTANCE) { - builder.append(StringUtils.format("Map {} = {}.readStringPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); - return map; + switch (language) { + case Enhance: + builder.append(StringUtils.format("Map {} = {}.readStringPacketMap($1, {});", map, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(((ObjectProtocolField) valueRegistration).getProtocolId()))); + return map; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringPacketMap({});", map, ((ObjectProtocolField) valueRegistration).getProtocolId())).append(LS); + return map; + } } } } - GenerateProtocolFile.index.getAndDecrement(); return null; } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java index 97ce3e5e..8d5644b1 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/CutDownSetSerializer.java @@ -21,6 +21,8 @@ import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; +import static com.zfoo.protocol.util.FileUtils.LS; + /** * @author jaysunxiao * @version 3.0 @@ -35,89 +37,256 @@ public class CutDownSetSerializer implements ICutDownSerializer { @Override public boolean writeObject(StringBuilder builder, String objectStr, Field field, IFieldRegistration fieldRegistration, CodeLanguage language) { - var setField = (SetField) fieldRegistration; + var flag = true; // 直接在字节码里调用方法是为了减小生成字节码的体积，下面的代码去掉也不会有任何影响 switch (setField.getType().getTypeName()) { + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeBooleanSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeBooleanArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeByteSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeByteArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeShortSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeShortArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeIntSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeIntArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeLongSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeLongArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeFloatSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeFloatArray({});", objectStr)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writeDoubleSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeDoubleArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("{}.writeStringSet($1, (Set){});", EnhanceUtils.byteBufUtils, objectStr)); - return true; + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writeStringArray({});", objectStr)).append(LS); + break; + default: + flag = false; } break; default: + // Set + if (setField.getSetElementRegistration() instanceof ObjectProtocolField) { + var objectProtocolField = (ObjectProtocolField) setField.getSetElementRegistration(); + switch (language) { + case Enhance: + builder.append(StringUtils.format("{}.writePacketSet($1, (Set){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); + break; + case JavaScript: + builder.append(StringUtils.format("byteBuffer.writePacketArray({}, {});", objectStr, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; + } + } else { + flag = false; + } } - // Set - if (setField.getSetElementRegistration() instanceof ObjectProtocolField) { - var objectProtocolField = (ObjectProtocolField) setField.getSetElementRegistration(); - switch (language) { - case Enhance: - builder.append(StringUtils.format("{}.writePacketSet($1, (Set){}, {});", EnhanceUtils.byteBufUtils, objectStr, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); - return true; - } - } - - return false; + return flag; } @Override public String readObject(StringBuilder builder, Field field, IFieldRegistration fieldRegistration, CodeLanguage language) { var setField = (SetField) fieldRegistration; var set = "set" + GenerateProtocolFile.index.getAndIncrement(); + var flag = true; switch (setField.getType().getTypeName()) { + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readBooleanSet($1);", set, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readBooleanArray();", set)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readByteSet($1);", set, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readByteArray();", set)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readShortSet($1);", set, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readShortArray();", set)).append(LS); + break; + default: + flag = false; + } + break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("Set {} = {}.readIntSet($1);", set, EnhanceUtils.byteBufUtils)); - return set; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readIntArray();", set)).append(LS); + break; + default: + flag = false; } break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("Set {} = {}.readLongSet($1);", set, EnhanceUtils.byteBufUtils)); - return set; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readLongArray();", set)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readFloatSet($1);", set, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readFloatArray();", set)).append(LS); + break; + default: + flag = false; + } + break; + case "java.util.Set": + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readDoubleSet($1);", set, EnhanceUtils.byteBufUtils)); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readDoubleArray();", set)).append(LS); + break; + default: + flag = false; } break; case "java.util.Set": switch (language) { case Enhance: builder.append(StringUtils.format("Set {} = {}.readStringSet($1);", set, EnhanceUtils.byteBufUtils)); - return set; + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readStringArray();", set)).append(LS); + break; + default: + flag = false; } break; default: + if (setField.getSetElementRegistration() instanceof ObjectProtocolField) { + var objectProtocolField = (ObjectProtocolField) setField.getSetElementRegistration(); + switch (language) { + case Enhance: + builder.append(StringUtils.format("Set {} = {}.readPacketSet($1, {});", set, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); + break; + case JavaScript: + builder.append(StringUtils.format("const {} = byteBuffer.readPacketArray({});", set, objectProtocolField.getProtocolId())).append(LS); + break; + default: + flag = false; + } + } else { + flag = false; + } } - if (setField.getSetElementRegistration() instanceof ObjectProtocolField) { - var objectProtocolField = (ObjectProtocolField) setField.getSetElementRegistration(); - switch (language) { - case Enhance: - builder.append(StringUtils.format("Set {} = {}.readPacketSet($1, {});", set, EnhanceUtils.byteBufUtils, EnhanceUtils.getProtocolRegistrationFieldNameByProtocolId(objectProtocolField.getProtocolId()))); - return set; - } + + if (flag) { return set; + } else { + GenerateProtocolFile.index.getAndDecrement(); + return null; } - - GenerateProtocolFile.index.getAndDecrement(); - return null; } } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/GenerateJsUtils.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/GenerateJsUtils.java index c9767d6c..516fcb8b 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/GenerateJsUtils.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/GenerateJsUtils.java @@ -128,19 +128,6 @@ public abstract class GenerateJsUtils { var jsBuilder = new StringBuilder(); - // 如果协议包含子协议，则需要导入ProtocolManager - var subProtocols = ProtocolAnalysis.getAllSubProtocolIds(protocolId); - if (CollectionUtils.isNotEmpty(subProtocols)) { - var path = GenerateProtocolPath.getProtocolPath(protocolId); - if (StringUtils.isBlank(path)) { - jsBuilder.append("import ProtocolManager from './ProtocolManager.js';").append(LS); - } else { - jsBuilder.append("import ProtocolManager from '"); - Arrays.stream(path.split(StringUtils.SLASH)).forEach(it -> jsBuilder.append("../")); - jsBuilder.append("ProtocolManager.js';").append(LS); - } - } - // export object jsBuilder.append(exportFunction(registration)); @@ -223,15 +210,12 @@ public abstract class GenerateJsUtils { var protocolClazzName = registration.getConstructor().getDeclaringClass().getSimpleName(); var jsBuilder = new StringBuilder(); - jsBuilder.append(StringUtils.format("{}.writeObject = function(byteBuffer, packet) {", protocolClazzName)).append(LS); + jsBuilder.append(StringUtils.format("{}.write = function(byteBuffer, packet) {", protocolClazzName)).append(LS); - jsBuilder.append(TAB).append("if (packet === null) {").append(LS); - jsBuilder.append(TAB + TAB).append("byteBuffer.writeBoolean(false);").append(LS); + jsBuilder.append(TAB).append("if (byteBuffer.writePacketFlag(packet)) {").append(LS); jsBuilder.append(TAB + TAB).append("return;").append(LS); jsBuilder.append(TAB).append("}").append(LS); - jsBuilder.append(TAB).append("byteBuffer.writeBoolean(true);").append(LS); - for (int i = 0; i < fields.length; i++) { Field field = fields[i]; IFieldRegistration fieldRegistration = fieldRegistrations[i]; @@ -250,7 +234,7 @@ public abstract class GenerateJsUtils { var protocolClazzName = registration.getConstructor().getDeclaringClass().getSimpleName(); var jsBuilder = new StringBuilder(); - jsBuilder.append(StringUtils.format("{}.readObject = function(byteBuffer) {", protocolClazzName)).append(LS); + jsBuilder.append(StringUtils.format("{}.read = function(byteBuffer) {", protocolClazzName)).append(LS); jsBuilder.append(TAB).append("if (!byteBuffer.readBoolean()) {").append(LS); jsBuilder.append(TAB + TAB).append("return null;").append(LS); jsBuilder.append(TAB).append("}").append(LS); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsArraySerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsArraySerializer.java index 0be38268..0d7c2543 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsArraySerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsArraySerializer.java @@ -16,6 +16,8 @@ package com.zfoo.protocol.serializer.js; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.registration.field.ArrayField; import com.zfoo.protocol.registration.field.IFieldRegistration; +import com.zfoo.protocol.serializer.CodeLanguage; +import com.zfoo.protocol.serializer.CutDownArraySerializer; import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; @@ -31,9 +33,13 @@ public class JsArraySerializer implements IJsSerializer { @Override public void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + if (CutDownArraySerializer.getInstance().writeObject(builder, objectStr, field, fieldRegistration, CodeLanguage.JavaScript)) { + return; + } + ArrayField arrayField = (ArrayField) fieldRegistration; - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("if ({} === null) {", objectStr)).append(LS); GenerateProtocolFile.addTab(builder, deep + 1); builder.append("byteBuffer.writeInt(0);").append(LS); @@ -56,10 +62,15 @@ public class JsArraySerializer implements IJsSerializer { @Override public String readObject(StringBuilder builder, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + var cutDown = CutDownArraySerializer.getInstance().readObject(builder, field, fieldRegistration, CodeLanguage.JavaScript); + if (cutDown != null) { + return cutDown; + } + ArrayField arrayField = (ArrayField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("const {} = [];", result)).append(LS); String i = "index" + GenerateProtocolFile.index.getAndIncrement(); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsListSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsListSerializer.java index e5c56e1f..2eacd96f 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsListSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsListSerializer.java @@ -16,6 +16,8 @@ package com.zfoo.protocol.serializer.js; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.ListField; +import com.zfoo.protocol.serializer.CodeLanguage; +import com.zfoo.protocol.serializer.CutDownListSerializer; import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; @@ -30,9 +32,13 @@ public class JsListSerializer implements IJsSerializer { @Override public void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + if (CutDownListSerializer.getInstance().writeObject(builder, objectStr, field, fieldRegistration, CodeLanguage.JavaScript)) { + return; + } + ListField listField = (ListField) fieldRegistration; - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("if ({} === null) {", objectStr)).append(LS); GenerateProtocolFile.addTab(builder, deep + 1); builder.append("byteBuffer.writeInt(0);").append(LS); @@ -55,10 +61,15 @@ public class JsListSerializer implements IJsSerializer { @Override public String readObject(StringBuilder builder, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + var cutDown = CutDownListSerializer.getInstance().readObject(builder, field, fieldRegistration, CodeLanguage.JavaScript); + if (cutDown != null) { + return cutDown; + } + ListField listField = (ListField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("const {} = [];", result)).append(LS); GenerateProtocolFile.addTab(builder, deep); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsMapSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsMapSerializer.java index fa6aaf14..18394a53 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsMapSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsMapSerializer.java @@ -16,6 +16,8 @@ package com.zfoo.protocol.serializer.js; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.MapField; +import com.zfoo.protocol.serializer.CodeLanguage; +import com.zfoo.protocol.serializer.CutDownMapSerializer; import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; @@ -30,9 +32,12 @@ public class JsMapSerializer implements IJsSerializer { @Override public void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration) { - MapField mapField = (MapField) fieldRegistration; - GenerateProtocolFile.addTab(builder, deep); + if (CutDownMapSerializer.getInstance().writeObject(builder, objectStr, field, fieldRegistration, CodeLanguage.JavaScript)) { + return; + } + + MapField mapField = (MapField) fieldRegistration; builder.append(StringUtils.format("if ({} === null) {", objectStr)).append(LS); GenerateProtocolFile.addTab(builder, deep + 1); builder.append("byteBuffer.writeInt(0);").append(LS); @@ -60,10 +65,15 @@ public class JsMapSerializer implements IJsSerializer { @Override public String readObject(StringBuilder builder, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + var cutDown = CutDownMapSerializer.getInstance().readObject(builder, field, fieldRegistration, CodeLanguage.JavaScript); + if (cutDown != null) { + return cutDown; + } + MapField mapField = (MapField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("const {} = new Map();", result)).append(LS); GenerateProtocolFile.addTab(builder, deep); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsObjectProtocolSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsObjectProtocolSerializer.java index 416d76ca..41acb0b4 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsObjectProtocolSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsObjectProtocolSerializer.java @@ -32,7 +32,7 @@ public class JsObjectProtocolSerializer implements IJsSerializer { public void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration) { ObjectProtocolField objectProtocolField = (ObjectProtocolField) fieldRegistration; GenerateProtocolFile.addTab(builder, deep); - builder.append(StringUtils.format("ProtocolManager.getProtocol({}).writeObject(byteBuffer, {});", objectProtocolField.getProtocolId(), objectStr)).append(LS); + builder.append(StringUtils.format("byteBuffer.writePacket({}, {});", objectStr, objectProtocolField.getProtocolId())).append(LS); } @Override @@ -40,7 +40,7 @@ public class JsObjectProtocolSerializer implements IJsSerializer { ObjectProtocolField objectProtocolField = (ObjectProtocolField) fieldRegistration; var result = "result" + GenerateProtocolFile.index.getAndIncrement(); GenerateProtocolFile.addTab(builder, deep); - builder.append(StringUtils.format("const {} = ProtocolManager.getProtocol({}).readObject(byteBuffer);", result, objectProtocolField.getProtocolId())).append(LS); + builder.append(StringUtils.format("const {} = byteBuffer.readPacket({});", result, objectProtocolField.getProtocolId())).append(LS); return result; } } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsSetSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsSetSerializer.java index 0b4634b0..84c67378 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsSetSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/js/JsSetSerializer.java @@ -16,6 +16,8 @@ package com.zfoo.protocol.serializer.js; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.SetField; +import com.zfoo.protocol.serializer.CodeLanguage; +import com.zfoo.protocol.serializer.CutDownSetSerializer; import com.zfoo.protocol.util.StringUtils; import java.lang.reflect.Field; @@ -30,9 +32,13 @@ public class JsSetSerializer implements IJsSerializer { @Override public void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + if (CutDownSetSerializer.getInstance().writeObject(builder, objectStr, field, fieldRegistration, CodeLanguage.JavaScript)) { + return; + } + SetField setField = (SetField) fieldRegistration; - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("if ({} === null) {", objectStr)).append(LS); GenerateProtocolFile.addTab(builder, deep + 1); builder.append("byteBuffer.writeInt(0);").append(LS); @@ -56,10 +62,15 @@ public class JsSetSerializer implements IJsSerializer { @Override public String readObject(StringBuilder builder, int deep, Field field, IFieldRegistration fieldRegistration) { + GenerateProtocolFile.addTab(builder, deep); + var cutDown = CutDownSetSerializer.getInstance().readObject(builder, field, fieldRegistration, CodeLanguage.JavaScript); + if (cutDown != null) { + return cutDown; + } + SetField setField = (SetField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - GenerateProtocolFile.addTab(builder, deep); builder.append(StringUtils.format("const {} = new Set();", result)).append(LS); GenerateProtocolFile.addTab(builder, deep); diff --git a/protocol/src/main/resources/js/ProtocolManager.js b/protocol/src/main/resources/js/ProtocolManager.js index d7315498..36f7f470 100644 --- a/protocol/src/main/resources/js/ProtocolManager.js +++ b/protocol/src/main/resources/js/ProtocolManager.js @@ -14,13 +14,13 @@ ProtocolManager.write = function write(byteBuffer, packet) { const protocolId = packet.protocolId(); byteBuffer.writeShort(protocolId); const protocol = ProtocolManager.getProtocol(protocolId); - protocol.writeObject(byteBuffer, packet); + protocol.write(byteBuffer, packet); }; ProtocolManager.read = function read(byteBuffer) { const protocolId = byteBuffer.readShort(); const protocol = ProtocolManager.getProtocol(protocolId); - const packet = protocol.readObject(byteBuffer); + const packet = protocol.read(byteBuffer); return packet; }; diff --git a/protocol/src/main/resources/js/buffer/ByteBuffer.js b/protocol/src/main/resources/js/buffer/ByteBuffer.js index 0c77f3c7..70cdebfb 100644 --- a/protocol/src/main/resources/js/buffer/ByteBuffer.js +++ b/protocol/src/main/resources/js/buffer/ByteBuffer.js @@ -1,5 +1,7 @@ -import {readInt64, writeInt64} from './longbits.js'; +import { readInt64, writeInt64 } from './longbits.js'; +import ProtocolManager from '../ProtocolManager.js'; +const empty_str = ''; const initSize = 128; const maxSize = 655537; @@ -41,22 +43,22 @@ function decodeZigzagInt(n) { } -const ByteBuffer = function () { +const ByteBuffer = function() { this.writeOffset = 0; this.readOffset = 0; this.buffer = new ArrayBuffer(initSize); this.bufferView = new DataView(this.buffer, 0, this.buffer.byteLength); - this.setWriteOffset = function (writeOffset) { + this.setWriteOffset = function(writeOffset) { if (writeOffset > this.buffer.byteLength) { throw new Error('index out of bounds exception: readerIndex: ' + this.readOffset + - ', writerIndex: ' + this.writeOffset + - '(expected: 0 <= readerIndex <= writerIndex <= capacity:' + this.buffer.byteLength); + ', writerIndex: ' + this.writeOffset + + '(expected: 0 <= readerIndex <= writerIndex <= capacity:' + this.buffer.byteLength); } this.writeOffset = writeOffset; }; - this.setReadOffset = function (readOffset) { + this.setReadOffset = function(readOffset) { if (readOffset > this.writeOffset) { throw new Error('index out of bounds exception: readerIndex: ' + this.readOffset + ', writerIndex: ' + this.writeOffset + @@ -65,11 +67,11 @@ const ByteBuffer = function () { this.readOffset = readOffset; }; - this.getCapacity = function () { + this.getCapacity = function() { return this.buffer.byteLength - this.writeOffset; }; - this.ensureCapacity = function (minCapacity) { + this.ensureCapacity = function(minCapacity) { while (minCapacity - this.getCapacity() > 0) { const newSize = this.buffer.byteLength * 2; if (newSize > maxSize) { @@ -80,7 +82,7 @@ const ByteBuffer = function () { } }; - this.writeBoolean = function (value) { + this.writeBoolean = function(value) { if (!(value === true || value === false)) { throw new Error('value must be true of false'); } @@ -93,32 +95,32 @@ const ByteBuffer = function () { this.writeOffset++; }; - this.readBoolean = function () { + this.readBoolean = function() { const value = this.bufferView.getInt8(this.readOffset); this.readOffset++; return (value === 1); }; - this.writeBytes = function (byteArray) { + this.writeBytes = function(byteArray) { const length = byteArray.byteLength; this.ensureCapacity(length); new Uint8Array(this.buffer).set(new Uint8Array(byteArray), this.writeOffset); this.writeOffset += length; }; - this.writeByte = function (value) { + this.writeByte = function(value) { this.ensureCapacity(1); this.bufferView.setInt8(this.writeOffset, value); this.writeOffset++; }; - this.readByte = function () { + this.readByte = function() { const value = this.bufferView.getInt8(this.readOffset); this.readOffset++; return value; }; - this.writeShort = function (value) { + this.writeShort = function(value) { if (!(minShort <= value && value <= maxShort)) { throw new Error('value must range between minShort:-32768 and maxShort:32767'); } @@ -127,13 +129,13 @@ const ByteBuffer = function () { this.writeOffset += 2; }; - this.readShort = function () { + this.readShort = function() { const value = this.bufferView.getInt16(this.readOffset); this.readOffset += 2; return value; }; - this.writeRawInt = function (value) { + this.writeRawInt = function(value) { if (!(minInt <= value && value <= maxInt)) { throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); } @@ -142,13 +144,13 @@ const ByteBuffer = function () { this.writeOffset += 4; }; - this.readRawInt = function () { + this.readRawInt = function() { const value = this.bufferView.getInt32(this.readOffset); this.readOffset += 4; return value; }; - this.writeInt = function (value) { + this.writeInt = function(value) { if (!(minInt <= value && value <= maxInt)) { throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); } @@ -189,7 +191,7 @@ const ByteBuffer = function () { this.writeByte(value >>> 28); }; - this.readInt = function () { + this.readInt = function() { let b = this.readByte(); let value = b & 0x7F; if ((b & 0x80) !== 0) { @@ -212,7 +214,7 @@ const ByteBuffer = function () { return decodeZigzagInt(value); }; - this.writeLong = function (value) { + this.writeLong = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -221,7 +223,7 @@ const ByteBuffer = function () { writeInt64(this, value); }; - this.readLong = function () { + this.readLong = function() { const buffer = new ArrayBuffer(9); const bufferView = new DataView(buffer, 0, buffer.byteLength); @@ -263,7 +265,7 @@ const ByteBuffer = function () { return readInt64(new Uint8Array(buffer.slice(0, count))).toString(); }; - this.writeFloat = function (value) { + this.writeFloat = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -272,13 +274,13 @@ const ByteBuffer = function () { this.writeOffset += 4; }; - this.readFloat = function () { + this.readFloat = function() { const value = this.bufferView.getFloat32(this.readOffset); this.readOffset += 4; return value; }; - this.writeDouble = function (value) { + this.writeDouble = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -287,25 +289,25 @@ const ByteBuffer = function () { this.writeOffset += 8; }; - this.readDouble = function () { + this.readDouble = function() { const value = this.bufferView.getFloat64(this.readOffset); this.readOffset += 8; return value; }; - this.writeChar = function (value) { + this.writeChar = function(value) { if (value === null || value === undefined || value.length === 0) { - this.writeInt(0); + this.writeString(empty_str); return; } this.writeString(value.charAt(0)); }; - this.readChar = function () { + this.readChar = function() { return this.readString(); }; - this.writeString = function (value) { + this.writeString = function(value) { if (value === null || value === undefined || value.trim().length === 0) { this.writeInt(0); return; @@ -319,10 +321,10 @@ const ByteBuffer = function () { uint8Array.forEach((value) => this.writeByte(value)); }; - this.readString = function () { + this.readString = function() { const length = this.readInt(); if (length <= 0) { - return ''; + return empty_str; } const uint8Array = new Uint8Array(this.buffer.slice(this.readOffset, this.readOffset + length)); const value = decoder.decode(uint8Array); @@ -330,11 +332,555 @@ const ByteBuffer = function () { return value; }; - this.toBytes = function () { + this.toBytes = function() { const result = new ArrayBuffer(this.writeOffset); new Uint8Array(result).set(new Uint8Array(this.buffer.slice(0, this.writeOffset))); return result; }; + + this.writePacketFlag = function(value) { + const flag = value === null; + this.writeBoolean(!flag); + return flag; + }; + + this.writePacket = function(value, protocolId) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + protocolRegistration.write(this, value); + }; + + this.readPacket = function(protocolId) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + return protocolRegistration.read(this); + }; + + this.writeBooleanArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + this.readBooleanArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readBoolean()); + } + } + return array; + }; + + this.writeByteArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeByte(element); + }); + } + }; + + this.readByteArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readByte()); + } + } + return array; + }; + + this.writeShortArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeShort(element); + }); + } + }; + + this.readShortArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readShort()); + } + } + return array; + }; + + this.writeIntArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeInt(element); + }); + } + }; + + this.readIntArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readInt()); + } + } + return array; + }; + + this.writeLongArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeLong(element); + }); + } + }; + + this.readLongArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readLong()); + } + } + return array; + }; + + this.writeFloatArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeFloat(element); + }); + } + }; + + this.readFloatArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readFloat()); + } + } + return array; + }; + + this.writeDoubleArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeDouble(element); + }); + } + }; + + this.readDoubleArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readDouble()); + } + } + return array; + }; + + this.writeStringArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeString(element); + }); + } + }; + + this.readStringArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readString()); + } + } + return array; + }; + + this.writeCharArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeChar(element); + }); + } + }; + + this.readCharArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readChar()); + } + } + return array; + }; + + this.writePacketArray = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.length); + value.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + this.readPacketArray = function(protocolId) { + const array = []; + const length = this.readInt(); + if (length > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < length; index++) { + array.push(protocolRegistration.read(this)); + } + } + return array; + }; + + this.writeIntIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeInt(value); + }); + } + }; + + this.readIntIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeLong(value); + }); + } + }; + + this.readIntLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeString(value); + }); + } + }; + + this.readIntStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readIntPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; + + this.writeLongIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeInt(value); + }); + } + }; + + this.readLongIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeLong(value); + }); + } + }; + + this.readLongLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeString(value); + }); + } + }; + + this.readLongStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readLongPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; + + this.writeStringIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeInt(value); + }); + } + }; + + this.readStringIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeLong(value); + }); + } + }; + + this.readStringLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeString(value); + }); + } + }; + + this.readStringStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readStringPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; }; export default ByteBuffer; diff --git a/protocol/src/test/java/com/zfoo/protocol/SpeedTest.java b/protocol/src/test/java/com/zfoo/protocol/SpeedTest.java index d467a3ba..20a567c8 100644 --- a/protocol/src/test/java/com/zfoo/protocol/SpeedTest.java +++ b/protocol/src/test/java/com/zfoo/protocol/SpeedTest.java @@ -22,6 +22,7 @@ import com.google.protobuf.CodedOutputStream; import com.zfoo.protocol.collection.ArrayUtils; import com.zfoo.protocol.generate.GenerateOperation; import com.zfoo.protocol.packet.*; +import com.zfoo.protocol.serializer.CodeLanguage; import com.zfoo.protocol.util.StringUtils; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufAllocator; @@ -323,10 +324,8 @@ public class SpeedTest { static { var op = GenerateOperation.NO_OPERATION; -// op.setGenerateLuaProtocol(true); -// op.setGenerateCsharpProtocol(true); -// op.setGenerateJsProtocol(true); -// op.setFoldProtocol(true); + op.getGenerateLanguages().add(CodeLanguage.JavaScript); + op.setFoldProtocol(true); // zfoo协议注册 ProtocolManager.initProtocol(Set.of(ComplexObject.class, NormalObject.class, SimpleObject.class, ObjectA.class, ObjectB.class), op); diff --git a/protocol/src/test/java/com/zfoo/protocol/packet/ComplexObject.java b/protocol/src/test/java/com/zfoo/protocol/packet/ComplexObject.java index 27f69372..8bdb3a11 100644 --- a/protocol/src/test/java/com/zfoo/protocol/packet/ComplexObject.java +++ b/protocol/src/test/java/com/zfoo/protocol/packet/ComplexObject.java @@ -26,7 +26,7 @@ import java.util.*; */ public class ComplexObject implements IPacket { - public static final transient short PROTOCOL_ID = 1160; + public static final transient short PROTOCOL_ID = 100; // byte类型，最简单的整形 private byte a; diff --git a/protocol/src/test/java/com/zfoo/protocol/packet/NormalObject.java b/protocol/src/test/java/com/zfoo/protocol/packet/NormalObject.java index 0e165377..97184882 100644 --- a/protocol/src/test/java/com/zfoo/protocol/packet/NormalObject.java +++ b/protocol/src/test/java/com/zfoo/protocol/packet/NormalObject.java @@ -25,7 +25,7 @@ import java.util.Set; */ public class NormalObject implements IPacket { - public static final transient short PROTOCOL_ID = 1161; + public static final transient short PROTOCOL_ID = 101; private byte a; private byte[] aaa; diff --git a/protocol/src/test/java/com/zfoo/protocol/packet/ObjectA.java b/protocol/src/test/java/com/zfoo/protocol/packet/ObjectA.java index e092c79a..f95ab721 100644 --- a/protocol/src/test/java/com/zfoo/protocol/packet/ObjectA.java +++ b/protocol/src/test/java/com/zfoo/protocol/packet/ObjectA.java @@ -24,7 +24,7 @@ import java.util.Objects; */ public class ObjectA implements IPacket { - public static final transient short PROTOCOL_ID = 1116; + public static final transient short PROTOCOL_ID = 102; private int a; diff --git a/protocol/src/test/java/com/zfoo/protocol/packet/ObjectB.java b/protocol/src/test/java/com/zfoo/protocol/packet/ObjectB.java index 4eb35f64..65b0c7d1 100644 --- a/protocol/src/test/java/com/zfoo/protocol/packet/ObjectB.java +++ b/protocol/src/test/java/com/zfoo/protocol/packet/ObjectB.java @@ -23,7 +23,7 @@ import java.util.Objects; */ public class ObjectB implements IPacket { - public static final transient short PROTOCOL_ID = 1117; + public static final transient short PROTOCOL_ID = 103; private boolean flag; diff --git a/protocol/src/test/java/com/zfoo/protocol/packet/SimpleObject.java b/protocol/src/test/java/com/zfoo/protocol/packet/SimpleObject.java index f3c0fe38..a46d7986 100644 --- a/protocol/src/test/java/com/zfoo/protocol/packet/SimpleObject.java +++ b/protocol/src/test/java/com/zfoo/protocol/packet/SimpleObject.java @@ -21,7 +21,7 @@ import com.zfoo.protocol.IPacket; */ public class SimpleObject implements IPacket { - public static final transient short PROTOCOL_ID = 1163; + public static final transient short PROTOCOL_ID = 104; private int c; diff --git a/protocol/src/test/resources/ComplexObject.bytes b/protocol/src/test/resources/ComplexObject.bytes index 372f9c8aa88e5eb7d0080029c2323fe24ae49ad8..7ef502dadd1a3fdf644eb2b7aed6158bf595271d 100644 GIT binary patch literal 2214 zcmZQbVN6cuYM9HATn{1D`PKQk8W{f1Wnch`{YPT{YhE7@!hHXMfd4O$b(E3e7$aC1 zB!Wx)-~aYMXZIXdhS5SG{b2AHDuZSgOgU5)sp@_9?NI<>KA;a6&j1;Rj-NRTWHUGc zX^=#H{r~@XB^{?Z}{7i{pK2z#Z zMy8}=j7%wv3@n6|5LSUJuG!dd$&e~O2n}K*94^#QF}$onN}FuBlO=U!*q8{%0}oyos)pH^ aa5);A#2;`SgGI+Lumlmg1F3kx<5~ccH%l-8 literal 2214 zcmZSSU`$TtYM9HATn{1D`PKQk8W{f1Wnch`{YPT{YhE7@!hHXMfd4O$b(E3e7$aC1 zB!Wx)-~aYMXZIXdhS5SG{b2AHDuZSgOgU5)sp@_9?NI<>KA;a6&j1;Rj-NRTWHUGc zX^=#H{r~@XB^{?oyos)pH^ aa5);A#2;|wf|$ diff --git a/protocol/src/test/resources/jsTest/jsProtocol/ProtocolManager.js b/protocol/src/test/resources/jsTest/jsProtocol/ProtocolManager.js index c0a7f1c9..63cc4ce6 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/ProtocolManager.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/ProtocolManager.js @@ -1,7 +1,7 @@ -import ObjectA from './packet/ObjectA.js'; -import ObjectB from './packet/ObjectB.js'; import ComplexObject from './packet/ComplexObject.js'; import NormalObject from './packet/NormalObject.js'; +import ObjectA from './packet/ObjectA.js'; +import ObjectB from './packet/ObjectB.js'; import SimpleObject from './packet/SimpleObject.js'; @@ -21,22 +21,22 @@ ProtocolManager.write = function write(byteBuffer, packet) { const protocolId = packet.protocolId(); byteBuffer.writeShort(protocolId); const protocol = ProtocolManager.getProtocol(protocolId); - protocol.writeObject(byteBuffer, packet); + protocol.write(byteBuffer, packet); }; ProtocolManager.read = function read(byteBuffer) { const protocolId = byteBuffer.readShort(); const protocol = ProtocolManager.getProtocol(protocolId); - const packet = protocol.readObject(byteBuffer); + const packet = protocol.read(byteBuffer); return packet; }; ProtocolManager.initProtocol = function initProtocol() { - protocols.set(1116, ObjectA); - protocols.set(1117, ObjectB); - protocols.set(1160, ComplexObject); - protocols.set(1161, NormalObject); - protocols.set(1163, SimpleObject); + protocols.set(100, ComplexObject); + protocols.set(101, NormalObject); + protocols.set(102, ObjectA); + protocols.set(103, ObjectB); + protocols.set(104, SimpleObject); }; export default ProtocolManager; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/buffer/ByteBuffer.js b/protocol/src/test/resources/jsTest/jsProtocol/buffer/ByteBuffer.js index 2ed62166..ac94be24 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/buffer/ByteBuffer.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/buffer/ByteBuffer.js @@ -1,5 +1,7 @@ -import {readInt64, writeInt64} from './longbits.js'; +import { readInt64, writeInt64 } from './longbits.js'; +import ProtocolManager from '../ProtocolManager.js'; +const empty_str = ''; const initSize = 128; const maxSize = 655537; @@ -41,22 +43,22 @@ function decodeZigzagInt(n) { } -const ByteBuffer = function () { +const ByteBuffer = function() { this.writeOffset = 0; this.readOffset = 0; this.buffer = new ArrayBuffer(initSize); this.bufferView = new DataView(this.buffer, 0, this.buffer.byteLength); - this.setWriteOffset = function (writeOffset) { + this.setWriteOffset = function(writeOffset) { if (writeOffset > this.buffer.byteLength) { throw new Error('index out of bounds exception: readerIndex: ' + this.readOffset + - ', writerIndex: ' + this.writeOffset + - '(expected: 0 <= readerIndex <= writerIndex <= capacity:' + this.buffer.byteLength); + ', writerIndex: ' + this.writeOffset + + '(expected: 0 <= readerIndex <= writerIndex <= capacity:' + this.buffer.byteLength); } this.writeOffset = writeOffset; }; - this.setReadOffset = function (readOffset) { + this.setReadOffset = function(readOffset) { if (readOffset > this.writeOffset) { throw new Error('index out of bounds exception: readerIndex: ' + this.readOffset + ', writerIndex: ' + this.writeOffset + @@ -65,11 +67,11 @@ const ByteBuffer = function () { this.readOffset = readOffset; }; - this.getCapacity = function () { + this.getCapacity = function() { return this.buffer.byteLength - this.writeOffset; }; - this.ensureCapacity = function (minCapacity) { + this.ensureCapacity = function(minCapacity) { while (minCapacity - this.getCapacity() > 0) { const newSize = this.buffer.byteLength * 2; if (newSize > maxSize) { @@ -80,7 +82,7 @@ const ByteBuffer = function () { } }; - this.writeBoolean = function (value) { + this.writeBoolean = function(value) { if (!(value === true || value === false)) { throw new Error('value must be true of false'); } @@ -93,32 +95,32 @@ const ByteBuffer = function () { this.writeOffset++; }; - this.readBoolean = function () { + this.readBoolean = function() { const value = this.bufferView.getInt8(this.readOffset); this.readOffset++; return (value === 1); }; - this.writeBytes = function (byteArray) { + this.writeBytes = function(byteArray) { const length = byteArray.byteLength; this.ensureCapacity(length); new Uint8Array(this.buffer).set(new Uint8Array(byteArray), this.writeOffset); this.writeOffset += length; }; - this.writeByte = function (value) { + this.writeByte = function(value) { this.ensureCapacity(1); this.bufferView.setInt8(this.writeOffset, value); this.writeOffset++; }; - this.readByte = function () { + this.readByte = function() { const value = this.bufferView.getInt8(this.readOffset); this.readOffset++; return value; }; - this.writeShort = function (value) { + this.writeShort = function(value) { if (!(minShort <= value && value <= maxShort)) { throw new Error('value must range between minShort:-32768 and maxShort:32767'); } @@ -127,13 +129,13 @@ const ByteBuffer = function () { this.writeOffset += 2; }; - this.readShort = function () { + this.readShort = function() { const value = this.bufferView.getInt16(this.readOffset); this.readOffset += 2; return value; }; - this.writeRawInt = function (value) { + this.writeRawInt = function(value) { if (!(minInt <= value && value <= maxInt)) { throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); } @@ -142,13 +144,13 @@ const ByteBuffer = function () { this.writeOffset += 4; }; - this.readRawInt = function () { + this.readRawInt = function() { const value = this.bufferView.getInt32(this.readOffset); this.readOffset += 4; return value; }; - this.writeInt = function (value) { + this.writeInt = function(value) { if (!(minInt <= value && value <= maxInt)) { throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); } @@ -189,7 +191,7 @@ const ByteBuffer = function () { this.writeByte(value >>> 28); }; - this.readInt = function () { + this.readInt = function() { let b = this.readByte(); let value = b & 0x7F; if ((b & 0x80) !== 0) { @@ -212,7 +214,7 @@ const ByteBuffer = function () { return decodeZigzagInt(value); }; - this.writeLong = function (value) { + this.writeLong = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -221,7 +223,7 @@ const ByteBuffer = function () { writeInt64(this, value); }; - this.readLong = function () { + this.readLong = function() { const buffer = new ArrayBuffer(9); const bufferView = new DataView(buffer, 0, buffer.byteLength); @@ -263,7 +265,7 @@ const ByteBuffer = function () { return readInt64(new Uint8Array(buffer.slice(0, count))).toString(); }; - this.writeFloat = function (value) { + this.writeFloat = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -272,13 +274,13 @@ const ByteBuffer = function () { this.writeOffset += 4; }; - this.readFloat = function () { + this.readFloat = function() { const value = this.bufferView.getFloat32(this.readOffset); this.readOffset += 4; return value; }; - this.writeDouble = function (value) { + this.writeDouble = function(value) { if (value === null || value === undefined) { throw new Error('value must not be null'); } @@ -287,25 +289,25 @@ const ByteBuffer = function () { this.writeOffset += 8; }; - this.readDouble = function () { + this.readDouble = function() { const value = this.bufferView.getFloat64(this.readOffset); this.readOffset += 8; return value; }; - this.writeChar = function (value) { + this.writeChar = function(value) { if (value === null || value === undefined || value.length === 0) { - this.writeInt(0); + this.writeString(empty_str); return; } this.writeString(value.charAt(0)); }; - this.readChar = function () { + this.readChar = function() { return this.readString(); }; - this.writeString = function (value) { + this.writeString = function(value) { if (value === null || value === undefined || value.trim().length === 0) { this.writeInt(0); return; @@ -319,10 +321,10 @@ const ByteBuffer = function () { uint8Array.forEach((value) => this.writeByte(value)); }; - this.readString = function () { + this.readString = function() { const length = this.readInt(); if (length <= 0) { - return ''; + return empty_str; } const uint8Array = new Uint8Array(this.buffer.slice(this.readOffset, this.readOffset + length)); const value = decoder.decode(uint8Array); @@ -330,11 +332,555 @@ const ByteBuffer = function () { return value; }; - this.toBytes = function () { + this.toBytes = function() { const result = new ArrayBuffer(this.writeOffset); new Uint8Array(result).set(new Uint8Array(this.buffer.slice(0, this.writeOffset))); return result; }; + + this.writePacketFlag = function(value) { + const flag = value === null; + this.writeBoolean(!flag); + return flag; + }; + + this.writePacket = function(value, protocolId) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + protocolRegistration.write(this, value); + }; + + this.readPacket = function(protocolId) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + return protocolRegistration.read(this); + }; + + this.writeBooleanArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + this.readBooleanArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readBoolean()); + } + } + return array; + }; + + this.writeByteArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeByte(element); + }); + } + }; + + this.readByteArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readByte()); + } + } + return array; + }; + + this.writeShortArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeShort(element); + }); + } + }; + + this.readShortArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readShort()); + } + } + return array; + }; + + this.writeIntArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeInt(element); + }); + } + }; + + this.readIntArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readInt()); + } + } + return array; + }; + + this.writeLongArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeLong(element); + }); + } + }; + + this.readLongArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readLong()); + } + } + return array; + }; + + this.writeFloatArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeFloat(element); + }); + } + }; + + this.readFloatArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readFloat()); + } + } + return array; + }; + + this.writeDoubleArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeDouble(element); + }); + } + }; + + this.readDoubleArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readDouble()); + } + } + return array; + }; + + this.writeStringArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeString(element); + }); + } + }; + + this.readStringArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readString()); + } + } + return array; + }; + + this.writeCharArray = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.length); + value.forEach(element => { + this.writeChar(element); + }); + } + }; + + this.readCharArray = function() { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readChar()); + } + } + return array; + }; + + this.writePacketArray = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.length); + value.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + this.readPacketArray = function(protocolId) { + const array = []; + const length = this.readInt(); + if (length > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < length; index++) { + array.push(protocolRegistration.read(this)); + } + } + return array; + }; + + this.writeIntIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeInt(value); + }); + } + }; + + this.readIntIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeLong(value); + }); + } + }; + + this.readIntLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + this.writeString(value); + }); + } + }; + + this.readIntStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeIntPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeInt(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readIntPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readInt(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; + + this.writeLongIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeInt(value); + }); + } + }; + + this.readLongIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeLong(value); + }); + } + }; + + this.readLongLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + this.writeString(value); + }); + } + }; + + this.readLongStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeLongPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeLong(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readLongPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readLong(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; + + this.writeStringIntMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeInt(value); + }); + } + }; + + this.readStringIntMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readInt(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringLongMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeLong(value); + }); + } + }; + + this.readStringLongMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readLong(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringStringMap = function(value) { + if (value === null) { + this.writeInt(0); + } else { + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + this.writeString(value); + }); + } + }; + + this.readStringStringMap = function() { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = this.readString(); + map.set(key, value); + } + } + return map; + }; + + this.writeStringPacketMap = function(value, protocolId) { + if (value === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(value.size); + value.forEach((value, key) => { + this.writeString(key); + protocolRegistration.write(this, value); + }); + } + }; + + this.readStringPacketMap = function(protocolId) { + const map = new Map(); + const size = this.readInt(); + if (size > 0) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + for (let index = 0; index < size; index++) { + const key = this.readString(); + const value = protocolRegistration.read(this); + map.set(key, value); + } + } + return map; + }; }; export default ByteBuffer; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/packet/ComplexObject.js b/protocol/src/test/resources/jsTest/jsProtocol/packet/ComplexObject.js index 21e1691b..3c21c107 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/packet/ComplexObject.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/packet/ComplexObject.js @@ -1,11 +1,9 @@ -import ProtocolManager from '../ProtocolManager.js'; // 复杂的对象 // 包括了各种复杂的结构，数组，List，Set，Map // // @author jaysunxiao -// @version 1.0 -// @since 2017 10.14 11:19 -const ComplexObject = function (a, aa, aaa, aaaa, b, bb, bbb, bbbb, c, cc, ccc, cccc, d, dd, ddd, dddd, e, ee, eee, eeee, f, ff, fff, ffff, g, gg, ggg, gggg, h, hh, hhh, hhhh, jj, jjj, kk, kkk, l, ll, lll, llll, lllll, m, mm, mmm, mmmm, mmmmm, s, ss, sss, ssss, sssss) { +// @version 3.0 +const ComplexObject = function(a, aa, aaa, aaaa, b, bb, bbb, bbbb, c, cc, ccc, cccc, d, dd, ddd, dddd, e, ee, eee, eeee, f, ff, fff, ffff, g, gg, ggg, gggg, h, hh, hhh, hhhh, jj, jjj, kk, kkk, l, ll, lll, llll, lllll, m, mm, mmm, mmmm, mmmmm, s, ss, sss, ssss, sssss) { // byte类型，最简单的整形 this.a = a; // byte // byte的包装类型 @@ -63,204 +61,62 @@ const ComplexObject = function (a, aa, aaa, aaaa, b, bb, bbb, bbbb, c, cc, ccc, this.sssss = sssss; // java.util.Set> }; -ComplexObject.prototype.protocolId = function () { - return 1160; +ComplexObject.prototype.protocolId = function() { + return 100; }; -ComplexObject.writeObject = function (byteBuffer, packet) { - if (packet === null) { - byteBuffer.writeBoolean(false); +ComplexObject.write = function(byteBuffer, packet) { + if (byteBuffer.writePacketFlag(packet)) { return; } - byteBuffer.writeBoolean(true); byteBuffer.writeByte(packet.a); byteBuffer.writeByte(packet.aa); - if (packet.aaa === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.aaa.length); - packet.aaa.forEach(element0 => { - byteBuffer.writeByte(element0); - }); - } - if (packet.aaaa === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.aaaa.length); - packet.aaaa.forEach(element1 => { - byteBuffer.writeByte(element1); - }); - } + byteBuffer.writeByteArray(packet.aaa); + byteBuffer.writeByteArray(packet.aaaa); byteBuffer.writeShort(packet.b); byteBuffer.writeShort(packet.bb); - if (packet.bbb === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.bbb.length); - packet.bbb.forEach(element2 => { - byteBuffer.writeShort(element2); - }); - } - if (packet.bbbb === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.bbbb.length); - packet.bbbb.forEach(element3 => { - byteBuffer.writeShort(element3); - }); - } + byteBuffer.writeShortArray(packet.bbb); + byteBuffer.writeShortArray(packet.bbbb); byteBuffer.writeInt(packet.c); byteBuffer.writeInt(packet.cc); - if (packet.ccc === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ccc.length); - packet.ccc.forEach(element4 => { - byteBuffer.writeInt(element4); - }); - } - if (packet.cccc === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.cccc.length); - packet.cccc.forEach(element5 => { - byteBuffer.writeInt(element5); - }); - } + byteBuffer.writeIntArray(packet.ccc); + byteBuffer.writeIntArray(packet.cccc); byteBuffer.writeLong(packet.d); byteBuffer.writeLong(packet.dd); - if (packet.ddd === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ddd.length); - packet.ddd.forEach(element6 => { - byteBuffer.writeLong(element6); - }); - } - if (packet.dddd === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.dddd.length); - packet.dddd.forEach(element7 => { - byteBuffer.writeLong(element7); - }); - } + byteBuffer.writeLongArray(packet.ddd); + byteBuffer.writeLongArray(packet.dddd); byteBuffer.writeFloat(packet.e); byteBuffer.writeFloat(packet.ee); - if (packet.eee === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.eee.length); - packet.eee.forEach(element8 => { - byteBuffer.writeFloat(element8); - }); - } - if (packet.eeee === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.eeee.length); - packet.eeee.forEach(element9 => { - byteBuffer.writeFloat(element9); - }); - } + byteBuffer.writeFloatArray(packet.eee); + byteBuffer.writeFloatArray(packet.eeee); byteBuffer.writeDouble(packet.f); byteBuffer.writeDouble(packet.ff); - if (packet.fff === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.fff.length); - packet.fff.forEach(element10 => { - byteBuffer.writeDouble(element10); - }); - } - if (packet.ffff === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ffff.length); - packet.ffff.forEach(element11 => { - byteBuffer.writeDouble(element11); - }); - } + byteBuffer.writeDoubleArray(packet.fff); + byteBuffer.writeDoubleArray(packet.ffff); byteBuffer.writeBoolean(packet.g); byteBuffer.writeBoolean(packet.gg); - if (packet.ggg === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ggg.length); - packet.ggg.forEach(element12 => { - byteBuffer.writeBoolean(element12); - }); - } - if (packet.gggg === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.gggg.length); - packet.gggg.forEach(element13 => { - byteBuffer.writeBoolean(element13); - }); - } + byteBuffer.writeBooleanArray(packet.ggg); + byteBuffer.writeBooleanArray(packet.gggg); byteBuffer.writeChar(packet.h); byteBuffer.writeChar(packet.hh); - if (packet.hhh === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.hhh.length); - packet.hhh.forEach(element14 => { - byteBuffer.writeChar(element14); - }); - } - if (packet.hhhh === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.hhhh.length); - packet.hhhh.forEach(element15 => { - byteBuffer.writeChar(element15); - }); - } + byteBuffer.writeCharArray(packet.hhh); + byteBuffer.writeCharArray(packet.hhhh); byteBuffer.writeString(packet.jj); - if (packet.jjj === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.jjj.length); - packet.jjj.forEach(element16 => { - byteBuffer.writeString(element16); - }); - } - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, packet.kk); - if (packet.kkk === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.kkk.length); - packet.kkk.forEach(element17 => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, element17); - }); - } - if (packet.l === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.l.length); - packet.l.forEach(element18 => { - byteBuffer.writeInt(element18); - }); - } + byteBuffer.writeStringArray(packet.jjj); + byteBuffer.writePacket(packet.kk, 102); + byteBuffer.writePacketArray(packet.kkk, 102); + byteBuffer.writeIntArray(packet.l); if (packet.ll === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.ll.length); - packet.ll.forEach(element19 => { - if (element19 === null) { + packet.ll.forEach(element0 => { + if (element0 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(element19.length); - element19.forEach(element20 => { - if (element20 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element20.length); - element20.forEach(element21 => { - byteBuffer.writeInt(element21); - }); - } + byteBuffer.writeInt(element0.length); + element0.forEach(element1 => { + byteBuffer.writeIntArray(element1); }); } }); @@ -269,113 +125,54 @@ ComplexObject.writeObject = function (byteBuffer, packet) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.lll.length); - packet.lll.forEach(element22 => { - if (element22 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element22.length); - element22.forEach(element23 => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, element23); - }); - } - }); - } - if (packet.llll === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.llll.length); - packet.llll.forEach(element24 => { - byteBuffer.writeString(element24); + packet.lll.forEach(element2 => { + byteBuffer.writePacketArray(element2, 102); }); } + byteBuffer.writeStringArray(packet.llll); if (packet.lllll === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.lllll.length); - packet.lllll.forEach(element25 => { - if (element25 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element25.size); - element25.forEach((value27, key26) => { - byteBuffer.writeInt(key26); - byteBuffer.writeString(value27); - }); - } - }); - } - if (packet.m === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.m.size); - packet.m.forEach((value29, key28) => { - byteBuffer.writeInt(key28); - byteBuffer.writeString(value29); - }); - } - if (packet.mm === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.mm.size); - packet.mm.forEach((value31, key30) => { - byteBuffer.writeInt(key30); - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, value31); + packet.lllll.forEach(element3 => { + byteBuffer.writeIntStringMap(element3); }); } + byteBuffer.writeIntStringMap(packet.m); + byteBuffer.writeIntPacketMap(packet.mm, 102); if (packet.mmm === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.mmm.size); - packet.mmm.forEach((value33, key32) => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, key32); - if (value33 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(value33.length); - value33.forEach(element34 => { - byteBuffer.writeInt(element34); - }); - } + packet.mmm.forEach((value5, key4) => { + byteBuffer.writePacket(key4, 102); + byteBuffer.writeIntArray(value5); }); } if (packet.mmmm === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.mmmm.size); - packet.mmmm.forEach((value36, key35) => { - if (key35 === null) { + packet.mmmm.forEach((value7, key6) => { + if (key6 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(key35.length); - key35.forEach(element37 => { - if (element37 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element37.length); - element37.forEach(element38 => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, element38); - }); - } + byteBuffer.writeInt(key6.length); + key6.forEach(element8 => { + byteBuffer.writePacketArray(element8, 102); }); } - if (value36 === null) { + if (value7 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(value36.length); - value36.forEach(element39 => { - if (element39 === null) { + byteBuffer.writeInt(value7.length); + value7.forEach(element9 => { + if (element9 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(element39.length); - element39.forEach(element40 => { - if (element40 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element40.length); - element40.forEach(element41 => { - byteBuffer.writeInt(element41); - }); - } + byteBuffer.writeInt(element9.length); + element9.forEach(element10 => { + byteBuffer.writeIntArray(element10); }); } }); @@ -386,67 +183,37 @@ ComplexObject.writeObject = function (byteBuffer, packet) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.mmmmm.size); - packet.mmmmm.forEach((value43, key42) => { - if (key42 === null) { + packet.mmmmm.forEach((value12, key11) => { + if (key11 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(key42.length); - key42.forEach(element44 => { - if (element44 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element44.size); - element44.forEach((value46, key45) => { - byteBuffer.writeInt(key45); - byteBuffer.writeString(value46); - }); - } + byteBuffer.writeInt(key11.length); + key11.forEach(element13 => { + byteBuffer.writeIntStringMap(element13); }); } - if (value43 === null) { + if (value12 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(value43.size); - value43.forEach(element47 => { - if (element47 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element47.size); - element47.forEach((value49, key48) => { - byteBuffer.writeInt(key48); - byteBuffer.writeString(value49); - }); - } + byteBuffer.writeInt(value12.size); + value12.forEach(element14 => { + byteBuffer.writeIntStringMap(element14); }); } }); } - if (packet.s === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.s.size); - packet.s.forEach(element50 => { - byteBuffer.writeInt(element50); - }); - } + byteBuffer.writeIntArray(packet.s); if (packet.ss === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.ss.size); - packet.ss.forEach(element51 => { - if (element51 === null) { + packet.ss.forEach(element15 => { + if (element15 === null) { byteBuffer.writeInt(0); } else { - byteBuffer.writeInt(element51.size); - element51.forEach(element52 => { - if (element52 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element52.length); - element52.forEach(element53 => { - byteBuffer.writeInt(element53); - }); - } + byteBuffer.writeInt(element15.size); + element15.forEach(element16 => { + byteBuffer.writeIntArray(element16); }); } }); @@ -455,516 +222,243 @@ ComplexObject.writeObject = function (byteBuffer, packet) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.sss.size); - packet.sss.forEach(element54 => { - if (element54 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element54.size); - element54.forEach(element55 => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, element55); - }); - } - }); - } - if (packet.ssss === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ssss.size); - packet.ssss.forEach(element56 => { - byteBuffer.writeString(element56); + packet.sss.forEach(element17 => { + byteBuffer.writePacketArray(element17, 102); }); } + byteBuffer.writeStringArray(packet.ssss); if (packet.sssss === null) { byteBuffer.writeInt(0); } else { byteBuffer.writeInt(packet.sssss.size); - packet.sssss.forEach(element57 => { - if (element57 === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(element57.size); - element57.forEach((value59, key58) => { - byteBuffer.writeInt(key58); - byteBuffer.writeString(value59); - }); - } + packet.sssss.forEach(element18 => { + byteBuffer.writeIntStringMap(element18); }); } }; -ComplexObject.readObject = function (byteBuffer) { +ComplexObject.read = function(byteBuffer) { if (!byteBuffer.readBoolean()) { return null; } const packet = new ComplexObject(); - const result60 = byteBuffer.readByte(); - packet.a = result60; - const result61 = byteBuffer.readByte(); - packet.aa = result61; - const result62 = []; + const result19 = byteBuffer.readByte(); + packet.a = result19; + const result20 = byteBuffer.readByte(); + packet.aa = result20; + const array21 = byteBuffer.readByteArray(); + packet.aaa = array21; + const array22 = byteBuffer.readByteArray(); + packet.aaaa = array22; + const result23 = byteBuffer.readShort(); + packet.b = result23; + const result24 = byteBuffer.readShort(); + packet.bb = result24; + const array25 = byteBuffer.readShortArray(); + packet.bbb = array25; + const array26 = byteBuffer.readShortArray(); + packet.bbbb = array26; + const result27 = byteBuffer.readInt(); + packet.c = result27; + const result28 = byteBuffer.readInt(); + packet.cc = result28; + const array29 = byteBuffer.readIntArray(); + packet.ccc = array29; + const array30 = byteBuffer.readIntArray(); + packet.cccc = array30; + const result31 = byteBuffer.readLong(); + packet.d = result31; + const result32 = byteBuffer.readLong(); + packet.dd = result32; + const array33 = byteBuffer.readLongArray(); + packet.ddd = array33; + const array34 = byteBuffer.readLongArray(); + packet.dddd = array34; + const result35 = byteBuffer.readFloat(); + packet.e = result35; + const result36 = byteBuffer.readFloat(); + packet.ee = result36; + const array37 = byteBuffer.readFloatArray(); + packet.eee = array37; + const array38 = byteBuffer.readFloatArray(); + packet.eeee = array38; + const result39 = byteBuffer.readDouble(); + packet.f = result39; + const result40 = byteBuffer.readDouble(); + packet.ff = result40; + const array41 = byteBuffer.readDoubleArray(); + packet.fff = array41; + const array42 = byteBuffer.readDoubleArray(); + packet.ffff = array42; + const result43 = byteBuffer.readBoolean(); + packet.g = result43; + const result44 = byteBuffer.readBoolean(); + packet.gg = result44; + const array45 = byteBuffer.readBooleanArray(); + packet.ggg = array45; + const array46 = byteBuffer.readBooleanArray(); + packet.gggg = array46; + const result47 = byteBuffer.readChar(); + packet.h = result47; + const result48 = byteBuffer.readChar(); + packet.hh = result48; + const array49 = byteBuffer.readCharArray(); + packet.hhh = array49; + const array50 = byteBuffer.readCharArray(); + packet.hhhh = array50; + const result51 = byteBuffer.readString(); + packet.jj = result51; + const array52 = byteBuffer.readStringArray(); + packet.jjj = array52; + const result53 = byteBuffer.readPacket(102); + packet.kk = result53; + const array54 = byteBuffer.readPacketArray(102); + packet.kkk = array54; + const list55 = byteBuffer.readIntArray(); + packet.l = list55; + const result56 = []; + const size57 = byteBuffer.readInt(); + if (size57 > 0) { + for (let index58 = 0; index58 < size57; index58++) { + const result59 = []; + const size60 = byteBuffer.readInt(); + if (size60 > 0) { + for (let index61 = 0; index61 < size60; index61++) { + const list62 = byteBuffer.readIntArray(); + result59.push(list62); + } + } + result56.push(result59); + } + } + packet.ll = result56; + const result63 = []; const size64 = byteBuffer.readInt(); if (size64 > 0) { - for (let index63 = 0; index63 < size64; index63++) { - const result65 = byteBuffer.readByte(); - result62.push(result65); + for (let index65 = 0; index65 < size64; index65++) { + const list66 = byteBuffer.readPacketArray(102); + result63.push(list66); } } - packet.aaa = result62; - const result66 = []; - const size68 = byteBuffer.readInt(); - if (size68 > 0) { - for (let index67 = 0; index67 < size68; index67++) { - const result69 = byteBuffer.readByte(); - result66.push(result69); + packet.lll = result63; + const list67 = byteBuffer.readStringArray(); + packet.llll = list67; + const result68 = []; + const size69 = byteBuffer.readInt(); + if (size69 > 0) { + for (let index70 = 0; index70 < size69; index70++) { + const map71 = byteBuffer.readIntStringMap(); + result68.push(map71); } } - packet.aaaa = result66; - const result70 = byteBuffer.readShort(); - packet.b = result70; - const result71 = byteBuffer.readShort(); - packet.bb = result71; - const result72 = []; - const size74 = byteBuffer.readInt(); - if (size74 > 0) { - for (let index73 = 0; index73 < size74; index73++) { - const result75 = byteBuffer.readShort(); - result72.push(result75); + packet.lllll = result68; + const map72 = byteBuffer.readIntStringMap(); + packet.m = map72; + const map73 = byteBuffer.readIntPacketMap(102); + packet.mm = map73; + const result74 = new Map(); + const size75 = byteBuffer.readInt(); + if (size75 > 0) { + for (let index76 = 0; index76 < size75; index76++) { + const result77 = byteBuffer.readPacket(102); + const list78 = byteBuffer.readIntArray(); + result74.set(result77, list78); } } - packet.bbb = result72; - const result76 = []; - const size78 = byteBuffer.readInt(); - if (size78 > 0) { - for (let index77 = 0; index77 < size78; index77++) { - const result79 = byteBuffer.readShort(); - result76.push(result79); + packet.mmm = result74; + const result79 = new Map(); + const size80 = byteBuffer.readInt(); + if (size80 > 0) { + for (let index81 = 0; index81 < size80; index81++) { + const result82 = []; + const size83 = byteBuffer.readInt(); + if (size83 > 0) { + for (let index84 = 0; index84 < size83; index84++) { + const list85 = byteBuffer.readPacketArray(102); + result82.push(list85); + } + } + const result86 = []; + const size87 = byteBuffer.readInt(); + if (size87 > 0) { + for (let index88 = 0; index88 < size87; index88++) { + const result89 = []; + const size90 = byteBuffer.readInt(); + if (size90 > 0) { + for (let index91 = 0; index91 < size90; index91++) { + const list92 = byteBuffer.readIntArray(); + result89.push(list92); + } + } + result86.push(result89); + } + } + result79.set(result82, result86); } } - packet.bbbb = result76; - const result80 = byteBuffer.readInt(); - packet.c = result80; - const result81 = byteBuffer.readInt(); - packet.cc = result81; - const result82 = []; - const size84 = byteBuffer.readInt(); - if (size84 > 0) { - for (let index83 = 0; index83 < size84; index83++) { - const result85 = byteBuffer.readInt(); - result82.push(result85); - } - } - packet.ccc = result82; - const result86 = []; - const size88 = byteBuffer.readInt(); - if (size88 > 0) { - for (let index87 = 0; index87 < size88; index87++) { - const result89 = byteBuffer.readInt(); - result86.push(result89); - } - } - packet.cccc = result86; - const result90 = byteBuffer.readLong(); - packet.d = result90; - const result91 = byteBuffer.readLong(); - packet.dd = result91; - const result92 = []; + packet.mmmm = result79; + const result93 = new Map(); const size94 = byteBuffer.readInt(); if (size94 > 0) { - for (let index93 = 0; index93 < size94; index93++) { - const result95 = byteBuffer.readLong(); - result92.push(result95); + for (let index95 = 0; index95 < size94; index95++) { + const result96 = []; + const size97 = byteBuffer.readInt(); + if (size97 > 0) { + for (let index98 = 0; index98 < size97; index98++) { + const map99 = byteBuffer.readIntStringMap(); + result96.push(map99); + } + } + const result100 = new Set(); + const size101 = byteBuffer.readInt(); + if (size101 > 0) { + for (let index102 = 0; index102 < size101; index102++) { + const map103 = byteBuffer.readIntStringMap(); + result100.add(map103); + } + } + result93.set(result96, result100); } } - packet.ddd = result92; - const result96 = []; - const size98 = byteBuffer.readInt(); - if (size98 > 0) { - for (let index97 = 0; index97 < size98; index97++) { - const result99 = byteBuffer.readLong(); - result96.push(result99); + packet.mmmmm = result93; + const set104 = byteBuffer.readIntArray(); + packet.s = set104; + const result105 = new Set(); + const size106 = byteBuffer.readInt(); + if (size106 > 0) { + for (let index107 = 0; index107 < size106; index107++) { + const result108 = new Set(); + const size109 = byteBuffer.readInt(); + if (size109 > 0) { + for (let index110 = 0; index110 < size109; index110++) { + const list111 = byteBuffer.readIntArray(); + result108.add(list111); + } + } + result105.add(result108); } } - packet.dddd = result96; - const result100 = byteBuffer.readFloat(); - packet.e = result100; - const result101 = byteBuffer.readFloat(); - packet.ee = result101; - const result102 = []; - const size104 = byteBuffer.readInt(); - if (size104 > 0) { - for (let index103 = 0; index103 < size104; index103++) { - const result105 = byteBuffer.readFloat(); - result102.push(result105); + packet.ss = result105; + const result112 = new Set(); + const size113 = byteBuffer.readInt(); + if (size113 > 0) { + for (let index114 = 0; index114 < size113; index114++) { + const set115 = byteBuffer.readPacketArray(102); + result112.add(set115); } } - packet.eee = result102; - const result106 = []; - const size108 = byteBuffer.readInt(); - if (size108 > 0) { - for (let index107 = 0; index107 < size108; index107++) { - const result109 = byteBuffer.readFloat(); - result106.push(result109); - } - } - packet.eeee = result106; - const result110 = byteBuffer.readDouble(); - packet.f = result110; - const result111 = byteBuffer.readDouble(); - packet.ff = result111; - const result112 = []; - const size114 = byteBuffer.readInt(); - if (size114 > 0) { - for (let index113 = 0; index113 < size114; index113++) { - const result115 = byteBuffer.readDouble(); - result112.push(result115); - } - } - packet.fff = result112; - const result116 = []; + packet.sss = result112; + const set116 = byteBuffer.readStringArray(); + packet.ssss = set116; + const result117 = new Set(); const size118 = byteBuffer.readInt(); if (size118 > 0) { - for (let index117 = 0; index117 < size118; index117++) { - const result119 = byteBuffer.readDouble(); - result116.push(result119); + for (let index119 = 0; index119 < size118; index119++) { + const map120 = byteBuffer.readIntStringMap(); + result117.add(map120); } } - packet.ffff = result116; - const result120 = byteBuffer.readBoolean(); - packet.g = result120; - const result121 = byteBuffer.readBoolean(); - packet.gg = result121; - const result122 = []; - const size124 = byteBuffer.readInt(); - if (size124 > 0) { - for (let index123 = 0; index123 < size124; index123++) { - const result125 = byteBuffer.readBoolean(); - result122.push(result125); - } - } - packet.ggg = result122; - const result126 = []; - const size128 = byteBuffer.readInt(); - if (size128 > 0) { - for (let index127 = 0; index127 < size128; index127++) { - const result129 = byteBuffer.readBoolean(); - result126.push(result129); - } - } - packet.gggg = result126; - const result130 = byteBuffer.readChar(); - packet.h = result130; - const result131 = byteBuffer.readChar(); - packet.hh = result131; - const result132 = []; - const size134 = byteBuffer.readInt(); - if (size134 > 0) { - for (let index133 = 0; index133 < size134; index133++) { - const result135 = byteBuffer.readChar(); - result132.push(result135); - } - } - packet.hhh = result132; - const result136 = []; - const size138 = byteBuffer.readInt(); - if (size138 > 0) { - for (let index137 = 0; index137 < size138; index137++) { - const result139 = byteBuffer.readChar(); - result136.push(result139); - } - } - packet.hhhh = result136; - const result140 = byteBuffer.readString(); - packet.jj = result140; - const result141 = []; - const size143 = byteBuffer.readInt(); - if (size143 > 0) { - for (let index142 = 0; index142 < size143; index142++) { - const result144 = byteBuffer.readString(); - result141.push(result144); - } - } - packet.jjj = result141; - const result145 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - packet.kk = result145; - const result146 = []; - const size148 = byteBuffer.readInt(); - if (size148 > 0) { - for (let index147 = 0; index147 < size148; index147++) { - const result149 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result146.push(result149); - } - } - packet.kkk = result146; - const result150 = []; - const size151 = byteBuffer.readInt(); - if (size151 > 0) { - for (let index152 = 0; index152 < size151; index152++) { - const result153 = byteBuffer.readInt(); - result150.push(result153); - } - } - packet.l = result150; - const result154 = []; - const size155 = byteBuffer.readInt(); - if (size155 > 0) { - for (let index156 = 0; index156 < size155; index156++) { - const result157 = []; - const size158 = byteBuffer.readInt(); - if (size158 > 0) { - for (let index159 = 0; index159 < size158; index159++) { - const result160 = []; - const size161 = byteBuffer.readInt(); - if (size161 > 0) { - for (let index162 = 0; index162 < size161; index162++) { - const result163 = byteBuffer.readInt(); - result160.push(result163); - } - } - result157.push(result160); - } - } - result154.push(result157); - } - } - packet.ll = result154; - const result164 = []; - const size165 = byteBuffer.readInt(); - if (size165 > 0) { - for (let index166 = 0; index166 < size165; index166++) { - const result167 = []; - const size168 = byteBuffer.readInt(); - if (size168 > 0) { - for (let index169 = 0; index169 < size168; index169++) { - const result170 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result167.push(result170); - } - } - result164.push(result167); - } - } - packet.lll = result164; - const result171 = []; - const size172 = byteBuffer.readInt(); - if (size172 > 0) { - for (let index173 = 0; index173 < size172; index173++) { - const result174 = byteBuffer.readString(); - result171.push(result174); - } - } - packet.llll = result171; - const result175 = []; - const size176 = byteBuffer.readInt(); - if (size176 > 0) { - for (let index177 = 0; index177 < size176; index177++) { - const result178 = new Map(); - const size179 = byteBuffer.readInt(); - if (size179 > 0) { - for (let index180 = 0; index180 < size179; index180++) { - const result181 = byteBuffer.readInt(); - const result182 = byteBuffer.readString(); - result178.set(result181, result182); - } - } - result175.push(result178); - } - } - packet.lllll = result175; - const result183 = new Map(); - const size184 = byteBuffer.readInt(); - if (size184 > 0) { - for (let index185 = 0; index185 < size184; index185++) { - const result186 = byteBuffer.readInt(); - const result187 = byteBuffer.readString(); - result183.set(result186, result187); - } - } - packet.m = result183; - const result188 = new Map(); - const size189 = byteBuffer.readInt(); - if (size189 > 0) { - for (let index190 = 0; index190 < size189; index190++) { - const result191 = byteBuffer.readInt(); - const result192 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result188.set(result191, result192); - } - } - packet.mm = result188; - const result193 = new Map(); - const size194 = byteBuffer.readInt(); - if (size194 > 0) { - for (let index195 = 0; index195 < size194; index195++) { - const result196 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - const result197 = []; - const size198 = byteBuffer.readInt(); - if (size198 > 0) { - for (let index199 = 0; index199 < size198; index199++) { - const result200 = byteBuffer.readInt(); - result197.push(result200); - } - } - result193.set(result196, result197); - } - } - packet.mmm = result193; - const result201 = new Map(); - const size202 = byteBuffer.readInt(); - if (size202 > 0) { - for (let index203 = 0; index203 < size202; index203++) { - const result204 = []; - const size205 = byteBuffer.readInt(); - if (size205 > 0) { - for (let index206 = 0; index206 < size205; index206++) { - const result207 = []; - const size208 = byteBuffer.readInt(); - if (size208 > 0) { - for (let index209 = 0; index209 < size208; index209++) { - const result210 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result207.push(result210); - } - } - result204.push(result207); - } - } - const result211 = []; - const size212 = byteBuffer.readInt(); - if (size212 > 0) { - for (let index213 = 0; index213 < size212; index213++) { - const result214 = []; - const size215 = byteBuffer.readInt(); - if (size215 > 0) { - for (let index216 = 0; index216 < size215; index216++) { - const result217 = []; - const size218 = byteBuffer.readInt(); - if (size218 > 0) { - for (let index219 = 0; index219 < size218; index219++) { - const result220 = byteBuffer.readInt(); - result217.push(result220); - } - } - result214.push(result217); - } - } - result211.push(result214); - } - } - result201.set(result204, result211); - } - } - packet.mmmm = result201; - const result221 = new Map(); - const size222 = byteBuffer.readInt(); - if (size222 > 0) { - for (let index223 = 0; index223 < size222; index223++) { - const result224 = []; - const size225 = byteBuffer.readInt(); - if (size225 > 0) { - for (let index226 = 0; index226 < size225; index226++) { - const result227 = new Map(); - const size228 = byteBuffer.readInt(); - if (size228 > 0) { - for (let index229 = 0; index229 < size228; index229++) { - const result230 = byteBuffer.readInt(); - const result231 = byteBuffer.readString(); - result227.set(result230, result231); - } - } - result224.push(result227); - } - } - const result232 = new Set(); - const size233 = byteBuffer.readInt(); - if (size233 > 0) { - for (let index234 = 0; index234 < size233; index234++) { - const result235 = new Map(); - const size236 = byteBuffer.readInt(); - if (size236 > 0) { - for (let index237 = 0; index237 < size236; index237++) { - const result238 = byteBuffer.readInt(); - const result239 = byteBuffer.readString(); - result235.set(result238, result239); - } - } - result232.add(result235); - } - } - result221.set(result224, result232); - } - } - packet.mmmmm = result221; - const result240 = new Set(); - const size241 = byteBuffer.readInt(); - if (size241 > 0) { - for (let index242 = 0; index242 < size241; index242++) { - const result243 = byteBuffer.readInt(); - result240.add(result243); - } - } - packet.s = result240; - const result244 = new Set(); - const size245 = byteBuffer.readInt(); - if (size245 > 0) { - for (let index246 = 0; index246 < size245; index246++) { - const result247 = new Set(); - const size248 = byteBuffer.readInt(); - if (size248 > 0) { - for (let index249 = 0; index249 < size248; index249++) { - const result250 = []; - const size251 = byteBuffer.readInt(); - if (size251 > 0) { - for (let index252 = 0; index252 < size251; index252++) { - const result253 = byteBuffer.readInt(); - result250.push(result253); - } - } - result247.add(result250); - } - } - result244.add(result247); - } - } - packet.ss = result244; - const result254 = new Set(); - const size255 = byteBuffer.readInt(); - if (size255 > 0) { - for (let index256 = 0; index256 < size255; index256++) { - const result257 = new Set(); - const size258 = byteBuffer.readInt(); - if (size258 > 0) { - for (let index259 = 0; index259 < size258; index259++) { - const result260 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result257.add(result260); - } - } - result254.add(result257); - } - } - packet.sss = result254; - const result261 = new Set(); - const size262 = byteBuffer.readInt(); - if (size262 > 0) { - for (let index263 = 0; index263 < size262; index263++) { - const result264 = byteBuffer.readString(); - result261.add(result264); - } - } - packet.ssss = result261; - const result265 = new Set(); - const size266 = byteBuffer.readInt(); - if (size266 > 0) { - for (let index267 = 0; index267 < size266; index267++) { - const result268 = new Map(); - const size269 = byteBuffer.readInt(); - if (size269 > 0) { - for (let index270 = 0; index270 < size269; index270++) { - const result271 = byteBuffer.readInt(); - const result272 = byteBuffer.readString(); - result268.set(result271, result272); - } - } - result265.add(result268); - } - } - packet.sssss = result265; + packet.sssss = result117; return packet; }; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/packet/NormalObject.js b/protocol/src/test/resources/jsTest/jsProtocol/packet/NormalObject.js index e25f76b6..73ed95c6 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/packet/NormalObject.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/packet/NormalObject.js @@ -1,29 +1,19 @@ -import ProtocolManager from '../ProtocolManager.js'; // @author jaysunxiao -// @version 1.0 -// @since 2021-02-07 17:18 -const NormalObject = function (a, aaa, b, bbb, c, ccc, d, ddd, e, eee, f, fff, g, ggg, h, hhh, jj, jjj, kk, kkk, l, llll, m, mm, s, ssss) { +// @version 3.0 +const NormalObject = function(a, aaa, b, c, d, e, f, g, jj, kk, l, ll, lll, llll, m, mm, s, ssss) { this.a = a; // byte this.aaa = aaa; // byte[] this.b = b; // short - this.bbb = bbb; // short[] this.c = c; // int - this.ccc = ccc; // int[] this.d = d; // long - this.ddd = ddd; // long[] this.e = e; // float - this.eee = eee; // float[] this.f = f; // double - this.fff = fff; // double[] this.g = g; // boolean - this.ggg = ggg; // boolean[] - this.h = h; // char - this.hhh = hhh; // char[] this.jj = jj; // java.lang.String - this.jjj = jjj; // java.lang.String[] this.kk = kk; // com.zfoo.protocol.packet.ObjectA - this.kkk = kkk; // com.zfoo.protocol.packet.ObjectA[] this.l = l; // java.util.List + this.ll = ll; // java.util.List + this.lll = lll; // java.util.List this.llll = llll; // java.util.List this.m = m; // java.util.Map this.mm = mm; // java.util.Map @@ -31,329 +21,75 @@ const NormalObject = function (a, aaa, b, bbb, c, ccc, d, ddd, e, eee, f, fff, g this.ssss = ssss; // java.util.Set }; -NormalObject.prototype.protocolId = function () { - return 1161; +NormalObject.prototype.protocolId = function() { + return 101; }; -NormalObject.writeObject = function (byteBuffer, packet) { - if (packet === null) { - byteBuffer.writeBoolean(false); +NormalObject.write = function(byteBuffer, packet) { + if (byteBuffer.writePacketFlag(packet)) { return; } - byteBuffer.writeBoolean(true); byteBuffer.writeByte(packet.a); - if (packet.aaa === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.aaa.length); - packet.aaa.forEach(element0 => { - byteBuffer.writeByte(element0); - }); - } + byteBuffer.writeByteArray(packet.aaa); byteBuffer.writeShort(packet.b); - if (packet.bbb === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.bbb.length); - packet.bbb.forEach(element1 => { - byteBuffer.writeShort(element1); - }); - } byteBuffer.writeInt(packet.c); - if (packet.ccc === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ccc.length); - packet.ccc.forEach(element2 => { - byteBuffer.writeInt(element2); - }); - } byteBuffer.writeLong(packet.d); - if (packet.ddd === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ddd.length); - packet.ddd.forEach(element3 => { - byteBuffer.writeLong(element3); - }); - } byteBuffer.writeFloat(packet.e); - if (packet.eee === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.eee.length); - packet.eee.forEach(element4 => { - byteBuffer.writeFloat(element4); - }); - } byteBuffer.writeDouble(packet.f); - if (packet.fff === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.fff.length); - packet.fff.forEach(element5 => { - byteBuffer.writeDouble(element5); - }); - } byteBuffer.writeBoolean(packet.g); - if (packet.ggg === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ggg.length); - packet.ggg.forEach(element6 => { - byteBuffer.writeBoolean(element6); - }); - } - byteBuffer.writeChar(packet.h); - if (packet.hhh === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.hhh.length); - packet.hhh.forEach(element7 => { - byteBuffer.writeChar(element7); - }); - } byteBuffer.writeString(packet.jj); - if (packet.jjj === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.jjj.length); - packet.jjj.forEach(element8 => { - byteBuffer.writeString(element8); - }); - } - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, packet.kk); - if (packet.kkk === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.kkk.length); - packet.kkk.forEach(element9 => { - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, element9); - }); - } - if (packet.l === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.l.length); - packet.l.forEach(element10 => { - byteBuffer.writeInt(element10); - }); - } - if (packet.llll === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.llll.length); - packet.llll.forEach(element11 => { - byteBuffer.writeString(element11); - }); - } - if (packet.m === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.m.size); - packet.m.forEach((value13, key12) => { - byteBuffer.writeInt(key12); - byteBuffer.writeString(value13); - }); - } - if (packet.mm === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.mm.size); - packet.mm.forEach((value15, key14) => { - byteBuffer.writeInt(key14); - ProtocolManager.getProtocol(1116).writeObject(byteBuffer, value15); - }); - } - if (packet.s === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.s.size); - packet.s.forEach(element16 => { - byteBuffer.writeInt(element16); - }); - } - if (packet.ssss === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.ssss.size); - packet.ssss.forEach(element17 => { - byteBuffer.writeString(element17); - }); - } + byteBuffer.writePacket(packet.kk, 102); + byteBuffer.writeIntArray(packet.l); + byteBuffer.writeLongArray(packet.ll); + byteBuffer.writePacketArray(packet.lll, 102); + byteBuffer.writeStringArray(packet.llll); + byteBuffer.writeIntStringMap(packet.m); + byteBuffer.writeIntPacketMap(packet.mm, 102); + byteBuffer.writeIntArray(packet.s); + byteBuffer.writeStringArray(packet.ssss); }; -NormalObject.readObject = function (byteBuffer) { +NormalObject.read = function(byteBuffer) { if (!byteBuffer.readBoolean()) { return null; } const packet = new NormalObject(); - const result18 = byteBuffer.readByte(); - packet.a = result18; - const result19 = []; - const size21 = byteBuffer.readInt(); - if (size21 > 0) { - for (let index20 = 0; index20 < size21; index20++) { - const result22 = byteBuffer.readByte(); - result19.push(result22); - } - } - packet.aaa = result19; - const result23 = byteBuffer.readShort(); - packet.b = result23; - const result24 = []; - const size26 = byteBuffer.readInt(); - if (size26 > 0) { - for (let index25 = 0; index25 < size26; index25++) { - const result27 = byteBuffer.readShort(); - result24.push(result27); - } - } - packet.bbb = result24; - const result28 = byteBuffer.readInt(); - packet.c = result28; - const result29 = []; - const size31 = byteBuffer.readInt(); - if (size31 > 0) { - for (let index30 = 0; index30 < size31; index30++) { - const result32 = byteBuffer.readInt(); - result29.push(result32); - } - } - packet.ccc = result29; - const result33 = byteBuffer.readLong(); - packet.d = result33; - const result34 = []; - const size36 = byteBuffer.readInt(); - if (size36 > 0) { - for (let index35 = 0; index35 < size36; index35++) { - const result37 = byteBuffer.readLong(); - result34.push(result37); - } - } - packet.ddd = result34; - const result38 = byteBuffer.readFloat(); - packet.e = result38; - const result39 = []; - const size41 = byteBuffer.readInt(); - if (size41 > 0) { - for (let index40 = 0; index40 < size41; index40++) { - const result42 = byteBuffer.readFloat(); - result39.push(result42); - } - } - packet.eee = result39; - const result43 = byteBuffer.readDouble(); - packet.f = result43; - const result44 = []; - const size46 = byteBuffer.readInt(); - if (size46 > 0) { - for (let index45 = 0; index45 < size46; index45++) { - const result47 = byteBuffer.readDouble(); - result44.push(result47); - } - } - packet.fff = result44; - const result48 = byteBuffer.readBoolean(); - packet.g = result48; - const result49 = []; - const size51 = byteBuffer.readInt(); - if (size51 > 0) { - for (let index50 = 0; index50 < size51; index50++) { - const result52 = byteBuffer.readBoolean(); - result49.push(result52); - } - } - packet.ggg = result49; - const result53 = byteBuffer.readChar(); - packet.h = result53; - const result54 = []; - const size56 = byteBuffer.readInt(); - if (size56 > 0) { - for (let index55 = 0; index55 < size56; index55++) { - const result57 = byteBuffer.readChar(); - result54.push(result57); - } - } - packet.hhh = result54; - const result58 = byteBuffer.readString(); - packet.jj = result58; - const result59 = []; - const size61 = byteBuffer.readInt(); - if (size61 > 0) { - for (let index60 = 0; index60 < size61; index60++) { - const result62 = byteBuffer.readString(); - result59.push(result62); - } - } - packet.jjj = result59; - const result63 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - packet.kk = result63; - const result64 = []; - const size66 = byteBuffer.readInt(); - if (size66 > 0) { - for (let index65 = 0; index65 < size66; index65++) { - const result67 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result64.push(result67); - } - } - packet.kkk = result64; - const result68 = []; - const size69 = byteBuffer.readInt(); - if (size69 > 0) { - for (let index70 = 0; index70 < size69; index70++) { - const result71 = byteBuffer.readInt(); - result68.push(result71); - } - } - packet.l = result68; - const result72 = []; - const size73 = byteBuffer.readInt(); - if (size73 > 0) { - for (let index74 = 0; index74 < size73; index74++) { - const result75 = byteBuffer.readString(); - result72.push(result75); - } - } - packet.llll = result72; - const result76 = new Map(); - const size77 = byteBuffer.readInt(); - if (size77 > 0) { - for (let index78 = 0; index78 < size77; index78++) { - const result79 = byteBuffer.readInt(); - const result80 = byteBuffer.readString(); - result76.set(result79, result80); - } - } - packet.m = result76; - const result81 = new Map(); - const size82 = byteBuffer.readInt(); - if (size82 > 0) { - for (let index83 = 0; index83 < size82; index83++) { - const result84 = byteBuffer.readInt(); - const result85 = ProtocolManager.getProtocol(1116).readObject(byteBuffer); - result81.set(result84, result85); - } - } - packet.mm = result81; - const result86 = new Set(); - const size87 = byteBuffer.readInt(); - if (size87 > 0) { - for (let index88 = 0; index88 < size87; index88++) { - const result89 = byteBuffer.readInt(); - result86.add(result89); - } - } - packet.s = result86; - const result90 = new Set(); - const size91 = byteBuffer.readInt(); - if (size91 > 0) { - for (let index92 = 0; index92 < size91; index92++) { - const result93 = byteBuffer.readString(); - result90.add(result93); - } - } - packet.ssss = result90; + const result0 = byteBuffer.readByte(); + packet.a = result0; + const array1 = byteBuffer.readByteArray(); + packet.aaa = array1; + const result2 = byteBuffer.readShort(); + packet.b = result2; + const result3 = byteBuffer.readInt(); + packet.c = result3; + const result4 = byteBuffer.readLong(); + packet.d = result4; + const result5 = byteBuffer.readFloat(); + packet.e = result5; + const result6 = byteBuffer.readDouble(); + packet.f = result6; + const result7 = byteBuffer.readBoolean(); + packet.g = result7; + const result8 = byteBuffer.readString(); + packet.jj = result8; + const result9 = byteBuffer.readPacket(102); + packet.kk = result9; + const list10 = byteBuffer.readIntArray(); + packet.l = list10; + const list11 = byteBuffer.readLongArray(); + packet.ll = list11; + const list12 = byteBuffer.readPacketArray(102); + packet.lll = list12; + const list13 = byteBuffer.readStringArray(); + packet.llll = list13; + const map14 = byteBuffer.readIntStringMap(); + packet.m = map14; + const map15 = byteBuffer.readIntPacketMap(102); + packet.mm = map15; + const set16 = byteBuffer.readIntArray(); + packet.s = set16; + const set17 = byteBuffer.readStringArray(); + packet.ssss = set17; return packet; }; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectA.js b/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectA.js index 0abdab2e..35fe1aff 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectA.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectA.js @@ -1,55 +1,35 @@ -import ProtocolManager from '../ProtocolManager.js'; // @author jaysunxiao -// @version 1.0 -// @since 2017 10.12 15:39 -const ObjectA = function (a, m, objectB) { +// @version 3.0 +const ObjectA = function(a, m, objectB) { this.a = a; // int this.m = m; // java.util.Map this.objectB = objectB; // com.zfoo.protocol.packet.ObjectB }; -ObjectA.prototype.protocolId = function () { - return 1116; +ObjectA.prototype.protocolId = function() { + return 102; }; -ObjectA.writeObject = function (byteBuffer, packet) { - if (packet === null) { - byteBuffer.writeBoolean(false); +ObjectA.write = function(byteBuffer, packet) { + if (byteBuffer.writePacketFlag(packet)) { return; } - byteBuffer.writeBoolean(true); byteBuffer.writeInt(packet.a); - if (packet.m === null) { - byteBuffer.writeInt(0); - } else { - byteBuffer.writeInt(packet.m.size); - packet.m.forEach((value1, key0) => { - byteBuffer.writeInt(key0); - byteBuffer.writeString(value1); - }); - } - ProtocolManager.getProtocol(1117).writeObject(byteBuffer, packet.objectB); + byteBuffer.writeIntStringMap(packet.m); + byteBuffer.writePacket(packet.objectB, 103); }; -ObjectA.readObject = function (byteBuffer) { +ObjectA.read = function(byteBuffer) { if (!byteBuffer.readBoolean()) { return null; } const packet = new ObjectA(); - const result2 = byteBuffer.readInt(); - packet.a = result2; - const result3 = new Map(); - const size4 = byteBuffer.readInt(); - if (size4 > 0) { - for (let index5 = 0; index5 < size4; index5++) { - const result6 = byteBuffer.readInt(); - const result7 = byteBuffer.readString(); - result3.set(result6, result7); - } - } - packet.m = result3; - const result8 = ProtocolManager.getProtocol(1117).readObject(byteBuffer); - packet.objectB = result8; + const result0 = byteBuffer.readInt(); + packet.a = result0; + const map1 = byteBuffer.readIntStringMap(); + packet.m = map1; + const result2 = byteBuffer.readPacket(103); + packet.objectB = result2; return packet; }; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectB.js b/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectB.js index 8ed4d4ac..0491a318 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectB.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/packet/ObjectB.js @@ -1,29 +1,26 @@ // @author jaysunxiao -// @version 1.0 -// @since 2017 10.12 15:39 -const ObjectB = function (flag) { +// @version 3.0 +const ObjectB = function(flag) { this.flag = flag; // boolean }; -ObjectB.prototype.protocolId = function () { - return 1117; +ObjectB.prototype.protocolId = function() { + return 103; }; -ObjectB.writeObject = function (byteBuffer, packet) { - if (packet === null) { - byteBuffer.writeBoolean(false); +ObjectB.write = function(byteBuffer, packet) { + if (byteBuffer.writePacketFlag(packet)) { return; } - byteBuffer.writeBoolean(true); byteBuffer.writeBoolean(packet.flag); }; -ObjectB.readObject = function (byteBuffer) { +ObjectB.read = function(byteBuffer) { if (!byteBuffer.readBoolean()) { return null; } const packet = new ObjectB(); - const result0 = byteBuffer.readBoolean(); + const result0 = byteBuffer.readBoolean(); packet.flag = result0; return packet; }; diff --git a/protocol/src/test/resources/jsTest/jsProtocol/packet/SimpleObject.js b/protocol/src/test/resources/jsTest/jsProtocol/packet/SimpleObject.js index d5b9c72f..8adebece 100644 --- a/protocol/src/test/resources/jsTest/jsProtocol/packet/SimpleObject.js +++ b/protocol/src/test/resources/jsTest/jsProtocol/packet/SimpleObject.js @@ -1,33 +1,30 @@ // @author jaysunxiao -// @version 1.0 -// @since 2021-03-27 15:18 -const SimpleObject = function (c, g) { +// @version 3.0 +const SimpleObject = function(c, g) { this.c = c; // int this.g = g; // boolean }; -SimpleObject.prototype.protocolId = function () { - return 1163; +SimpleObject.prototype.protocolId = function() { + return 104; }; -SimpleObject.writeObject = function (byteBuffer, packet) { - if (packet === null) { - byteBuffer.writeBoolean(false); +SimpleObject.write = function(byteBuffer, packet) { + if (byteBuffer.writePacketFlag(packet)) { return; } - byteBuffer.writeBoolean(true); byteBuffer.writeInt(packet.c); byteBuffer.writeBoolean(packet.g); }; -SimpleObject.readObject = function (byteBuffer) { +SimpleObject.read = function(byteBuffer) { if (!byteBuffer.readBoolean()) { return null; } const packet = new SimpleObject(); const result0 = byteBuffer.readInt(); packet.c = result0; - const result1 = byteBuffer.readBoolean(); + const result1 = byteBuffer.readBoolean(); packet.g = result1; return packet; }; diff --git a/protocol/src/test/resources/jsTest/jsProtocolTest.spec.js b/protocol/src/test/resources/jsTest/jsProtocolTest.spec.js index 0bee0407..21506ef9 100644 --- a/protocol/src/test/resources/jsTest/jsProtocolTest.spec.js +++ b/protocol/src/test/resources/jsTest/jsProtocolTest.spec.js @@ -4,16 +4,16 @@ import ProtocolManager from './jsProtocol/ProtocolManager.js'; const fs = require('fs'); describe('jsProtocolTest', () => { - it('complexObjectTest', () => { - const data = fs.readFileSync('D:\\zfoo\\protocol\\src\\test\\resources\\ComplexObject.bytes'); - - console.log(data.buffer); + const data = fs.readFileSync('C:\\zfoo\\protocol\\src\\test\\resources\\ComplexObject.bytes'); ProtocolManager.initProtocol(); + const arrayBytes = new Uint8Array(data.length); + data.copy(arrayBytes, 0, 0, data.length); + const byteBuffer = new ByteBuffer(); - byteBuffer.writeBytes(data.buffer); + byteBuffer.writeBytes(arrayBytes); const packet = ProtocolManager.read(byteBuffer); console.log(packet);