diff --git a/doc/idea/idea-set-up.md b/doc/idea/idea-set-up.md index 79a2848d..9776f945 100644 --- a/doc/idea/idea-set-up.md +++ b/doc/idea/idea-set-up.md @@ -15,7 +15,7 @@ 安装好以后，在git bash中输入：git --version，有结果返回则表示安装成功 ``` -- git下载代码慢的解决方法|无法下载代码的解决方法 +- git下载代码慢的解决方法|无法下载代码的解决方法，取消git配置使用git config --global --unset http.proxy ``` 使用vpn diff --git a/protocol/src/main/java/com/zfoo/protocol/generate/GenerateProtocolPath.java b/protocol/src/main/java/com/zfoo/protocol/generate/GenerateProtocolPath.java index aa289343..8856a0f0 100644 --- a/protocol/src/main/java/com/zfoo/protocol/generate/GenerateProtocolPath.java +++ b/protocol/src/main/java/com/zfoo/protocol/generate/GenerateProtocolPath.java @@ -57,13 +57,13 @@ public abstract class GenerateProtocolPath { var protocolPath = protocolPathMap.get(protocolId); var relativePath = protocolPathMap.get(relativeProtocolId); if (relativePath.startsWith(protocolPath)) { - return StringUtils.substringAfterFirst(relativePath, protocolPath).replaceAll(StringUtils.PERIOD_REGEX, StringUtils.SLASH); + return StringUtils.format(".{}", StringUtils.substringAfterFirst(relativePath, protocolPath).replaceAll(StringUtils.PERIOD_REGEX, StringUtils.SLASH)); } var splits = protocolPath.split(StringUtils.PERIOD_REGEX); var builder = new StringBuilder(); - for (var i = splits.length - 1; i > 0; i--) { + for (var i = splits.length; i > 0; i--) { builder.append("../"); var path = StringUtils.joinWith(StringUtils.PERIOD, Arrays.stream(splits).limit(i).collect(Collectors.toList()).toArray()); if (relativePath.startsWith(path)) { diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppListSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppListSerializer.java index 86708331..4afb85da 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppListSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppListSerializer.java @@ -35,8 +35,7 @@ public class CppListSerializer implements ICppSerializer { @Override public Pair field(Field field, IFieldRegistration fieldRegistration) { var type = GenerateCppUtils.toCppClassName(field.getGenericType().toString()); - var name = StringUtils.format("{}", field.getName()); - return new Pair<>(type, name); + return new Pair<>(type, field.getName()); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppMapSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppMapSerializer.java index 4fc860b8..74a05779 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppMapSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppMapSerializer.java @@ -35,8 +35,7 @@ public class CppMapSerializer implements ICppSerializer { @Override public Pair field(Field field, IFieldRegistration fieldRegistration) { var type = GenerateCppUtils.toCppClassName(field.getGenericType().toString()); - var name = StringUtils.format("{}", field.getName()); - return new Pair<>(type, name); + return new Pair<>(type, field.getName()); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppObjectProtocolSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppObjectProtocolSerializer.java index cd012a84..292adac3 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppObjectProtocolSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppObjectProtocolSerializer.java @@ -37,8 +37,7 @@ public class CppObjectProtocolSerializer implements ICppSerializer { ObjectProtocolField objectProtocolField = (ObjectProtocolField) fieldRegistration; var protocolSimpleName = EnhanceObjectProtocolSerializer.getProtocolClassSimpleName(objectProtocolField.getProtocolId()); var type = StringUtils.format("{}", protocolSimpleName); - var name = field.getName(); - return new Pair<>(type, name); + return new Pair<>(type, field.getName()); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppSetSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppSetSerializer.java index e62b9391..da2b54f5 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppSetSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/CppSetSerializer.java @@ -35,8 +35,7 @@ public class CppSetSerializer implements ICppSerializer { @Override public Pair field(Field field, IFieldRegistration fieldRegistration) { var type = GenerateCppUtils.toCppClassName(field.getGenericType().toString()); - var name = StringUtils.format("{}", field.getName()); - return new Pair<>(type, name); + return new Pair<>(type, field.getName()); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/GenerateCppUtils.java b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/GenerateCppUtils.java index 277250a6..e5871c4c 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/GenerateCppUtils.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/cpp/GenerateCppUtils.java @@ -408,6 +408,4 @@ public abstract class GenerateCppUtils { return typeName; } - - } diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/GenerateTsUtils.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/GenerateTsUtils.java index f1730a7f..7bcf5082 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/GenerateTsUtils.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/GenerateTsUtils.java @@ -122,13 +122,11 @@ public abstract class GenerateTsUtils { var importSubProtocol = importSubProtocol(registration); var docTitle = docTitle(registration); var fieldDefinition = fieldDefinition(registration); - var valueOfMethod = valueOfMethod(registration); var writeObject = writeObject(registration); var readObject = readObject(registration); protocolTemplate = StringUtils.format(protocolTemplate, importSubProtocol, docTitle, protocolClazzName, fieldDefinition.trim() - , valueOfMethod.getKey().trim(), valueOfMethod.getValue().trim(), protocolId, protocolClazzName - , writeObject.trim(), protocolClazzName, protocolClazzName, readObject.trim(), protocolClazzName); + , protocolId, protocolClazzName, writeObject.trim(), protocolClazzName, protocolClazzName, readObject.trim(), protocolClazzName); var protocolOutputPath = StringUtils.format("{}/{}/{}.ts", protocolOutputRootPath , GenerateProtocolPath.getProtocolPath(protocolId), protocolClazzName); FileUtils.writeStringToFile(new File(protocolOutputPath), protocolTemplate); @@ -144,8 +142,12 @@ public abstract class GenerateTsUtils { var importBuilder = new StringBuilder(); for (var subProtocolId : subProtocols) { var protocolClassName = EnhanceObjectProtocolSerializer.getProtocolClassSimpleName(subProtocolId); - var path = GenerateProtocolPath.getProtocolPath(protocolId); - importBuilder.append(StringUtils.format("import {} from './{}';", protocolClassName, protocolClassName)).append(LS); + var path = GenerateProtocolPath.getRelativePath(protocolId, subProtocolId); + if (StringUtils.isBlank(path)) { + importBuilder.append(StringUtils.format("import {} from './{}';", protocolClassName, protocolClassName)).append(LS); + } else { + importBuilder.append(StringUtils.format("import {} from '{}/{}';", protocolClassName, path, protocolClassName)).append(LS); + } } return importBuilder.toString(); } @@ -178,35 +180,12 @@ public abstract class GenerateTsUtils { Arrays.stream(doc.split(LS)).forEach(it -> fieldDefinitionBuilder.append(TAB).append(it).append(LS)); } - var propertyTypeAndName = tsSerializer(fieldRegistration.serializer()).field(field, fieldRegistration); - fieldDefinitionBuilder.append(TAB).append(StringUtils.format("{}: {};", propertyTypeAndName.getValue(), propertyTypeAndName.getKey())).append(LS); + var triple = tsSerializer(fieldRegistration.serializer()).field(field, fieldRegistration); + fieldDefinitionBuilder.append(TAB).append(StringUtils.format("{}{} = {};", triple.getMiddle(), triple.getLeft(), triple.getRight())).append(LS); } return fieldDefinitionBuilder.toString(); } - private static Pair valueOfMethod(ProtocolRegistration registration) { - var protocolId = registration.getId(); - var fields = registration.getFields(); - var fieldRegistrations = registration.getFieldRegistrations(); - - var filedList = new ArrayList>(); - for (int i = 0; i < fields.length; i++) { - var field = fields[i]; - var fieldRegistration = fieldRegistrations[i]; - var propertyTypeAndName = tsSerializer(fieldRegistration.serializer()).field(field, fieldRegistration); - filedList.add(propertyTypeAndName); - } - - var valueOfParams = filedList.stream() - .map(it -> StringUtils.format("{}: {}", it.getValue(), it.getKey())) - .collect(Collectors.toList()); - var valueOfParamsStr = StringUtils.joinWith(StringUtils.COMMA + " ", valueOfParams.toArray()); - - var cppBuilder = new StringBuilder(); - filedList.forEach(it -> cppBuilder.append(TAB + TAB).append(StringUtils.format("this.{} = {};", it.getValue(), it.getValue())).append(LS)); - return new Pair<>(valueOfParamsStr, cppBuilder.toString()); - } - private static String writeObject(ProtocolRegistration registration) { var fields = registration.getFields(); var fieldRegistrations = registration.getFieldRegistrations(); @@ -227,13 +206,98 @@ public abstract class GenerateTsUtils { var field = fields[i]; var fieldRegistration = fieldRegistrations[i]; if (field.isAnnotationPresent(Compatible.class)) { - jsBuilder.append(TAB).append("if (!buffer.isReadable()) {").append(LS); - jsBuilder.append(TAB + TAB).append("return packet;").append(LS); - jsBuilder.append(TAB).append("}").append(LS); + jsBuilder.append(TAB + TAB).append("if (!buffer.isReadable()) {").append(LS); + jsBuilder.append(TAB + TAB + TAB).append("return packet;").append(LS); + jsBuilder.append(TAB + TAB).append("}").append(LS); } var readObject = tsSerializer(fieldRegistration.serializer()).readObject(jsBuilder, 2, field, fieldRegistration); jsBuilder.append(TAB + TAB).append(StringUtils.format("packet.{} = {};", field.getName(), readObject)).append(LS); } return jsBuilder.toString(); } + + public static String toTsClassName(String typeName) { + typeName = typeName.replaceAll("java.util.|java.lang.", StringUtils.EMPTY); + typeName = typeName.replaceAll("com\\.[a-zA-Z0-9_.]*\\.", StringUtils.EMPTY); + + // CSharp不适用基础类型的泛型，会影响性能 + switch (typeName) { + case "boolean": + case "Boolean": + typeName = "boolean"; + return typeName; + case "byte": + case "Byte": + case "short": + case "Short": + case "int": + case "Integer": + case "long": + case "Long": + case "float": + case "Float": + case "double": + case "Double": + typeName = "number"; + return typeName; + case "char": + case "Character": + case "String": + typeName = "string"; + return typeName; + default: + } + + // 将boolean转为bool + typeName = typeName.replaceAll("[B|b]oolean\\[", "boolean"); + typeName = typeName.replace("", "boolean>"); + + // 将Byte转为byte + typeName = typeName.replace("Byte[", "number"); + typeName = typeName.replace("Byte>", "number>"); + typeName = typeName.replace("", "number>"); + typeName = typeName.replace("", "number>"); + typeName = typeName.replace("", "number>"); + typeName = typeName.replace("", "number>"); + typeName = typeName.replace("", "number>"); + typeName = typeName.replace("", "string>"); + typeName = typeName.replace("", "string>"); + typeName = typeName.replace(" field(Field field, IFieldRegistration fieldRegistration); + Triple field(Field field, IFieldRegistration fieldRegistration); void writeObject(StringBuilder builder, String objectStr, int deep, Field field, IFieldRegistration fieldRegistration); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsArraySerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsArraySerializer.java index 847b7116..1ad0e481 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsArraySerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsArraySerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.ArrayField; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.serializer.CodeLanguage; @@ -32,8 +32,9 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsArraySerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("Array", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + var type = StringUtils.format(": Array<{}> | null", GenerateTsUtils.toTsClassName(field.getType().getComponentType().getSimpleName())); + return new Triple<>(type, field.getName(), "null"); } @Override @@ -75,8 +76,8 @@ public class TsArraySerializer implements ITsSerializer { ArrayField arrayField = (ArrayField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - - builder.append(StringUtils.format("const {} = [];", result)).append(LS); + var typeName = GenerateTsUtils.toTsClassName(arrayField.getType().getSimpleName()); + builder.append(StringUtils.format("const {} = new {};", result, typeName)).append(LS); String i = "index" + GenerateProtocolFile.index.getAndIncrement(); String size = "size" + GenerateProtocolFile.index.getAndIncrement(); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsBooleanSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsBooleanSerializer.java index a663b201..eb0b5012 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsBooleanSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsBooleanSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsBooleanSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("boolean", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": boolean", field.getName(), "false"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsByteSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsByteSerializer.java index 197b3d04..df3fe3fd 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsByteSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsByteSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsByteSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsCharSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsCharSerializer.java index 87d64bca..ca9e49cb 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsCharSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsCharSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsCharSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("string", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": string", field.getName(), "''"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsDoubleSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsDoubleSerializer.java index 2eff4ccf..69ba4547 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsDoubleSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsDoubleSerializer.java @@ -15,6 +15,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +30,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsDoubleSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsFloatSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsFloatSerializer.java index 70d3c55a..744887fb 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsFloatSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsFloatSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsFloatSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsIntSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsIntSerializer.java index c098eef8..5fc198a1 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsIntSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsIntSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsIntSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsListSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsListSerializer.java index 3b7c9162..415449b5 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsListSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsListSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.ListField; import com.zfoo.protocol.serializer.CodeLanguage; @@ -32,8 +32,9 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsListSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("Array", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + var type = StringUtils.format(": {} | null", GenerateTsUtils.toTsClassName(field.getGenericType().toString())); + return new Triple<>(type, field.getName(), "null"); } @Override @@ -75,8 +76,8 @@ public class TsListSerializer implements ITsSerializer { ListField listField = (ListField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - - builder.append(StringUtils.format("const {} = [];", result)).append(LS); + var typeName = GenerateTsUtils.toTsClassName(listField.getType().toString()); + builder.append(StringUtils.format("const {} = new {}();", result, typeName)).append(LS); GenerateProtocolFile.addTab(builder, deep); String size = "size" + GenerateProtocolFile.index.getAndIncrement(); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsLongSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsLongSerializer.java index d7836d5f..85240432 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsLongSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsLongSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsLongSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsMapSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsMapSerializer.java index 6d5d6468..6bbcf2e1 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsMapSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsMapSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.MapField; import com.zfoo.protocol.serializer.CodeLanguage; @@ -32,8 +32,9 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsMapSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("Map", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + var type = StringUtils.format(": {} | null", GenerateTsUtils.toTsClassName(field.getGenericType().toString())); + return new Triple<>(type, field.getName(), "null"); } @Override @@ -79,8 +80,8 @@ public class TsMapSerializer implements ITsSerializer { MapField mapField = (MapField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - - builder.append(StringUtils.format("const {} = new Map();", result)).append(LS); + var typeName = GenerateTsUtils.toTsClassName(mapField.getType().toString()); + builder.append(StringUtils.format("const {} = new {}();", result, typeName)).append(LS); GenerateProtocolFile.addTab(builder, deep); String size = "size" + GenerateProtocolFile.index.getAndIncrement(); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsObjectProtocolSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsObjectProtocolSerializer.java index a64c44cc..1b9d68f9 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsObjectProtocolSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsObjectProtocolSerializer.java @@ -15,6 +15,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.ObjectProtocolField; import com.zfoo.protocol.serializer.enhance.EnhanceObjectProtocolSerializer; @@ -31,11 +32,11 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsObjectProtocolSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { + public Triple field(Field field, IFieldRegistration fieldRegistration) { ObjectProtocolField objectProtocolField = (ObjectProtocolField) fieldRegistration; var protocolSimpleName = EnhanceObjectProtocolSerializer.getProtocolClassSimpleName(objectProtocolField.getProtocolId()); - var type = StringUtils.format("{}", protocolSimpleName); - return new Pair<>(type, field.getName()); + var type = StringUtils.format(": {} | null", protocolSimpleName); + return new Triple<>(type, field.getName(), "null"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsSetSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsSetSerializer.java index 9960787b..b64f188b 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsSetSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsSetSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.registration.field.SetField; import com.zfoo.protocol.serializer.CodeLanguage; @@ -32,8 +32,9 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsSetSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("Set", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + var type = StringUtils.format(": {} | null", GenerateTsUtils.toTsClassName(field.getGenericType().toString())); + return new Triple<>(type, field.getName(), "null"); } @Override @@ -76,8 +77,8 @@ public class TsSetSerializer implements ITsSerializer { SetField setField = (SetField) fieldRegistration; String result = "result" + GenerateProtocolFile.index.getAndIncrement(); - - builder.append(StringUtils.format("const {} = new Set();", result)).append(LS); + var typeName = GenerateTsUtils.toTsClassName(setField.getType().toString()); + builder.append(StringUtils.format("const {} = new {}();", result, typeName)).append(LS); GenerateProtocolFile.addTab(builder, deep); String size = "size" + GenerateProtocolFile.index.getAndIncrement(); diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsShortSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsShortSerializer.java index 46d196a4..7abb320a 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsShortSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsShortSerializer.java @@ -15,6 +15,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +30,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsShortSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("number", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": number", field.getName(), "0"); } @Override diff --git a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsStringSerializer.java b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsStringSerializer.java index 680f44cd..fc67ce14 100644 --- a/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsStringSerializer.java +++ b/protocol/src/main/java/com/zfoo/protocol/serializer/typescript/TsStringSerializer.java @@ -14,7 +14,7 @@ package com.zfoo.protocol.serializer.typescript; import com.zfoo.protocol.generate.GenerateProtocolFile; -import com.zfoo.protocol.model.Pair; +import com.zfoo.protocol.model.Triple; import com.zfoo.protocol.registration.field.IFieldRegistration; import com.zfoo.protocol.util.StringUtils; @@ -29,8 +29,8 @@ import static com.zfoo.protocol.util.FileUtils.LS; public class TsStringSerializer implements ITsSerializer { @Override - public Pair field(Field field, IFieldRegistration fieldRegistration) { - return new Pair<>("string", field.getName()); + public Triple field(Field field, IFieldRegistration fieldRegistration) { + return new Triple<>(": string", field.getName(), "''"); } @Override diff --git a/protocol/src/main/resources/javascript/buffer/ByteBuffer.js b/protocol/src/main/resources/javascript/buffer/ByteBuffer.js index 0e55e7f0..2fcc66f4 100644 --- a/protocol/src/main/resources/javascript/buffer/ByteBuffer.js +++ b/protocol/src/main/resources/javascript/buffer/ByteBuffer.js @@ -723,8 +723,8 @@ const ByteBuffer = function() { }; this.writeLongSet = function(set) { - if (array === null) { - set.writeInt(0); + if (set === null) { + this.writeInt(0); } else { this.writeInt(set.size); set.forEach(element => { diff --git a/protocol/src/main/resources/typescript/ProtocolManagerTemplate.ts b/protocol/src/main/resources/typescript/ProtocolManagerTemplate.ts index 655ef2cb..a9e2673e 100644 --- a/protocol/src/main/resources/typescript/ProtocolManagerTemplate.ts +++ b/protocol/src/main/resources/typescript/ProtocolManagerTemplate.ts @@ -1,12 +1,12 @@ {} -const protocols = new Map(); +const protocols = new Map(); // initProtocol {} class ProtocolManager { - static getProtocol(): Any { + static getProtocol(protocolId: number): any { const protocol = protocols.get(protocolId); if (protocol === null) { throw new Error('[protocolId:' + protocolId + ']协议不存在'); @@ -14,14 +14,14 @@ class ProtocolManager { return protocol; } - static write(buffer: Any, packet: Any): void { + static write(buffer: any, packet: any): void { const protocolId = packet.protocolId(); buffer.writeShort(protocolId); - const protocol = getProtocol(protocolId); + const protocol = ProtocolManager.getProtocol(protocolId); protocol.write(buffer, packet); } - static read(buffer: Any): Any { + static read(buffer: any): any { const protocolId = buffer.readShort(); const protocol = ProtocolManager.getProtocol(protocolId); const packet = protocol.read(buffer); diff --git a/protocol/src/main/resources/typescript/ProtocolTemplate.ts b/protocol/src/main/resources/typescript/ProtocolTemplate.ts index 4dde5248..836a982a 100644 --- a/protocol/src/main/resources/typescript/ProtocolTemplate.ts +++ b/protocol/src/main/resources/typescript/ProtocolTemplate.ts @@ -4,19 +4,22 @@ class {} { {} - constructor({}) { - {} - } - protocolId(): number { return {}; } - static write(buffer: Any, packet: {}) { + static write(buffer: any, packet: {} | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + {} } - static read(buffer: Any): {} { + static read(buffer: any): {} | null { if (!buffer.readBoolean()) { return null; } diff --git a/protocol/src/main/resources/typescript/buffer/ByteBuffer.ts b/protocol/src/main/resources/typescript/buffer/ByteBuffer.ts index 2628a16e..841cacb1 100644 --- a/protocol/src/main/resources/typescript/buffer/ByteBuffer.ts +++ b/protocol/src/main/resources/typescript/buffer/ByteBuffer.ts @@ -1,3 +1,5 @@ +import ProtocolManager from "../ProtocolManager"; + const Longbits = require('./longbits.js'); const empty_str = ''; @@ -23,14 +25,14 @@ const decoder = new util.TextDecoder('utf-8'); // const maxLong = 9007199254740992; // const minLong = -9007199254740992; -const copy = function copy(original: ArrayBuffer, newLength: number) { +function copy(original: ArrayBuffer, newLength: number) { if (original.byteLength > newLength) { throw new Error('newLength is too small'); } const dst = new ArrayBuffer(newLength); new Uint8Array(dst).set(new Uint8Array(original)); return dst; -}; +} function encodeZigzagInt(n: number) { // 有效位左移一位+符号位右移31位 @@ -347,6 +349,784 @@ class ByteBuffer { this.readOffset += length; return value; } + + writePacketFlag(value: any): boolean { + const flag = (value === null) || (value === undefined); + this.writeBoolean(!flag); + return flag; + }; + + writePacket(packet: any, protocolId: number) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + protocolRegistration.write(this, packet); + }; + + readPacket(protocolId: number): any { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + return protocolRegistration.read(this); + }; + + writeBooleanArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + readBooleanArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readBoolean()); + } + } + return array; + }; + + writeByteArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeByte(element); + }); + } + }; + + readByteArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readByte()); + } + } + return array; + }; + + writeShortArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeShort(element); + }); + } + }; + + readShortArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readShort()); + } + } + return array; + }; + + writeIntArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeInt(element); + }); + } + }; + + readIntArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readInt()); + } + } + return array; + }; + + writeLongArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeLong(element); + }); + } + }; + + readLongArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readLong()); + } + } + return array; + }; + + writeFloatArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeFloat(element); + }); + } + }; + + readFloatArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readFloat()); + } + } + return array; + }; + + writeDoubleArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeDouble(element); + }); + } + }; + + readDoubleArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readDouble()); + } + } + return array; + }; + + writeStringArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeString(element); + }); + } + }; + + readStringArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readString()); + } + } + return array; + }; + + writeCharArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeChar(element); + }); + } + }; + + readCharArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readChar()); + } + } + return array; + }; + + writePacketArray(array: Array | null, protocolId: number) { + if (array === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(array.length); + array.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + readPacketArray(protocolId: number): any { + 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; + }; + + // ---------------------------------------------list------------------------------------------- + writeBooleanList(list: any) { + this.writeBooleanArray(list); + }; + + readBooleanList(): any { + return this.readBooleanArray(); + }; + + writeByteList(list: any) { + this.writeByteArray(list); + }; + + readByteList(): any { + return this.readByteArray(); + }; + + writeShortList(list: any) { + this.writeShortArray(list); + }; + + readShortList(): any { + return this.readShortArray(); + }; + + writeIntList(list: any) { + this.writeIntArray(list); + }; + + readIntList(): any { + return this.readIntArray(); + }; + + writeLongList(list: any) { + this.writeLongArray(list); + }; + + readLongList(): any { + return this.readLongArray(); + }; + + writeFloatList(list: any) { + this.writeFloatArray(list); + }; + + readFloatList(): any { + return this.readFloatArray(); + }; + + writeDoubleList(list: any) { + this.writeDoubleArray(list); + }; + + readDoubleList(): any { + return this.readDoubleArray(); + }; + + writeStringList(list: any) { + this.writeStringArray(list); + }; + + readStringList(): any { + return this.readStringArray(); + }; + + writeCharList(list: any) { + this.writeCharArray(list); + }; + + readCharList(): any { + return this.readCharArray(); + }; + + writePacketList(list: any, protocolId: number) { + this.writePacketArray(list, protocolId); + }; + + readPacketList(protocolId: number): any { + return this.readPacketArray(protocolId); + }; + + // ---------------------------------------------set------------------------------------------- + writeBooleanSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + readBooleanSet(): any { + return new Set(this.readBooleanArray()); + }; + + writeByteSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeByte(element); + }); + } + }; + + readByteSet(): any { + return new Set(this.readByteArray()); + }; + + writeShortSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeShort(element); + }); + } + }; + + readShortSet(): any { + return new Set(this.readShortArray()); + }; + + writeIntSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeInt(element); + }); + } + }; + + readIntSet(): any { + return new Set(this.readIntArray()); + }; + + writeLongSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeLong(element); + }); + } + }; + + readLongSet(): any { + return new Set(this.readLongArray()); + }; + + writeFloatSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeFloat(element); + }); + } + }; + + readFloatSet(): any { + return new Set(this.readFloatArray()); + }; + + writeDoubleSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeDouble(element); + }); + } + }; + + readDoubleSet(): any { + return new Set(this.readDoubleArray()); + }; + + writeStringSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeString(element); + }); + } + }; + + readStringSet(): any { + return new Set(this.readStringArray()); + }; + + writeCharSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeChar(element); + }); + } + }; + + readCharSet(): any { + return new Set(this.readCharArray()); + }; + + writePacketSet(set: Set | null, protocolId: number) { + if (set === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(set.size); + set.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + readPacketSet(protocolId: number): any { + return new Set(this.readPacketArray(protocolId)); + }; + + // ---------------------------------------------map------------------------------------------- + writeIntIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeInt(value); + }); + } + }; + + readIntIntMap(): any { + 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; + }; + + writeIntLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeLong(value); + }); + } + }; + + readIntLongMap(): any { + 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; + }; + + writeIntStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeString(value); + }); + } + }; + + readIntStringMap(): any { + 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; + }; + + writeIntPacketMap(map: Map | null, protocolId: number) { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + protocolRegistration.write(this, value); + }); + } + }; + + readIntPacketMap(protocolId: number): any { + 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; + }; + + writeLongIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeInt(value); + }); + } + }; + + readLongIntMap(): any { + 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; + }; + + writeLongLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeLong(value); + }); + } + }; + + readLongLongMap(): any { + 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; + }; + + writeLongStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeString(value); + }); + } + }; + + readLongStringMap(): any { + 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; + }; + + writeLongPacketMap(map: Map | null, protocolId: number): any { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + protocolRegistration.write(this, value); + }); + } + }; + + readLongPacketMap(protocolId: number): any { + 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; + }; + + writeStringIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeInt(value); + }); + } + }; + + readStringIntMap(): any { + 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; + }; + + writeStringLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeLong(value); + }); + } + }; + + readStringLongMap(): any { + 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; + }; + + writeStringStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeString(value); + }); + } + }; + + readStringStringMap(): any { + 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; + }; + + writeStringPacketMap(map: Map | null, protocolId: number) { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + protocolRegistration.write(this, value); + }); + } + }; + + readStringPacketMap(protocolId: number): any { + 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/typescript/main.ts b/protocol/src/test/typescript/main.ts index 2599eaf3..ee4ea5bb 100644 --- a/protocol/src/test/typescript/main.ts +++ b/protocol/src/test/typescript/main.ts @@ -1,4 +1,5 @@ -import ByteBuffer from './zfoojs/buffer/ByteBuffer'; +import ByteBuffer from './zfoo/buffer/ByteBuffer'; +import ProtocolManager from './zfoo/ProtocolManager'; function assert(flag: boolean): void { if (!flag) { @@ -10,6 +11,37 @@ function assert(flag: boolean): void { console.log("Hello world"); +const data = fs.readFileSync('C:\\zfoo\\protocol\\src\\test\\resources\\ComplexObject.bytes'); + +const arrayBytes = new Uint8Array(data.length); +data.copy(arrayBytes, 0, 0, data.length); + +const byteBuffer = new ByteBuffer(); +byteBuffer.writeBytes(arrayBytes); + +const packet = ProtocolManager.read(byteBuffer); +// complexObjec是老的协议，所以序列化回来myCompatible是nil，所以要重新赋值 +packet.myCompatible = 0 +console.log(packet); + +const newByteBuffer = new ByteBuffer(); +ProtocolManager.write(newByteBuffer, packet); + +const newPacket = ProtocolManager.read(newByteBuffer); +console.log(newPacket); + +assert(byteBuffer.readOffset <= newByteBuffer.writeOffset); + +// set和map是无序的，所以有的时候输入和输出的字节流有可能不一致，但是长度一定是一致的 +const length = newByteBuffer.writeOffset; +byteBuffer.setReadOffset(0); +newByteBuffer.setReadOffset(0); +for (let i = 0; i < length; i++) { + assert(byteBuffer.readByte() == newByteBuffer.readByte()); +} + + + // ByteBuffer test let buffer = new ByteBuffer(); diff --git a/protocol/src/test/typescript/zfoo/ProtocolManager.ts b/protocol/src/test/typescript/zfoo/ProtocolManager.ts new file mode 100644 index 00000000..83045848 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/ProtocolManager.ts @@ -0,0 +1,40 @@ +import ComplexObject from './packet/ComplexObject'; +import NormalObject from './packet/NormalObject'; +import ObjectA from './packet/ObjectA'; +import ObjectB from './packet/ObjectB'; +import SimpleObject from './packet/SimpleObject'; + +const protocols = new Map(); + +// initProtocol +protocols.set(100, ComplexObject); +protocols.set(101, NormalObject); +protocols.set(102, ObjectA); +protocols.set(103, ObjectB); +protocols.set(104, SimpleObject); + +class ProtocolManager { + static getProtocol(protocolId: number): any { + const protocol = protocols.get(protocolId); + if (protocol === null) { + throw new Error('[protocolId:' + protocolId + ']协议不存在'); + } + return protocol; + } + + static write(buffer: any, packet: any): void { + const protocolId = packet.protocolId(); + buffer.writeShort(protocolId); + const protocol = ProtocolManager.getProtocol(protocolId); + protocol.write(buffer, packet); + } + + static read(buffer: any): any { + const protocolId = buffer.readShort(); + const protocol = ProtocolManager.getProtocol(protocolId); + const packet = protocol.read(buffer); + return packet; + } +} + +export default ProtocolManager; diff --git a/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts b/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts new file mode 100644 index 00000000..841cacb1 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/buffer/ByteBuffer.ts @@ -0,0 +1,1132 @@ +import ProtocolManager from "../ProtocolManager"; + +const Longbits = require('./longbits.js'); + +const empty_str = ''; +const initSize = 128; +const maxSize = 655537; + +const maxShort = 32767; +const minShort = -32768; + +const maxInt = 2147483647; +const minInt = -2147483648; + +// UTF-8编码与解码 +// const encoder = new TextEncoder('utf-8'); +// const decoder = new TextDecoder('utf-8'); + +// nodejs的测试环境需要用以下方式特殊处理 +const util = require('util'); +const encoder = new util.TextEncoder('utf-8'); +const decoder = new util.TextDecoder('utf-8'); + +// 在js中long可以支持的最大值 +// const maxLong = 9007199254740992; +// const minLong = -9007199254740992; + +function copy(original: ArrayBuffer, newLength: number) { + if (original.byteLength > newLength) { + throw new Error('newLength is too small'); + } + const dst = new ArrayBuffer(newLength); + new Uint8Array(dst).set(new Uint8Array(original)); + return dst; +} + +function encodeZigzagInt(n: number) { + // 有效位左移一位+符号位右移31位 + return (n << 1) ^ (n >> 31); +} + +function decodeZigzagInt(n: number) { + return (n >>> 1) ^ -(n & 1); +} + + +class ByteBuffer { + writeOffset: number; + readOffset: number; + buffer: ArrayBuffer; + bufferView: DataView; + + constructor() { + this.writeOffset = 0; + this.readOffset = 0; + this.buffer = new ArrayBuffer(initSize); + this.bufferView = new DataView(this.buffer, 0, this.buffer.byteLength); + } + + setWriteOffset(writeOffset: number): void { + 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); + } + this.writeOffset = writeOffset; + } + + setReadOffset(readOffset: number): void { + if (readOffset > this.writeOffset) { + throw new Error('index out of bounds exception:readerIndex:' + this.readOffset + + ', writerIndex:' + this.writeOffset + + '(expected:0 <= readerIndex <= writerIndex <= capacity:' + this.buffer.byteLength); + } + this.readOffset = readOffset; + } + + getCapacity(): number { + return this.buffer.byteLength - this.writeOffset; + } + + ensureCapacity(minCapacity: number): void { + while (minCapacity - this.getCapacity() > 0) { + const newSize = this.buffer.byteLength * 2; + if (newSize > maxSize) { + throw new Error('out of memory error'); + } + this.buffer = copy(this.buffer, newSize); + this.bufferView = new DataView(this.buffer, 0, this.buffer.byteLength); + } + } + + isReadable(): boolean { + return this.writeOffset > this.readOffset; + } + + writeBytes(byteArray: ArrayBuffer): void { + const length = byteArray.byteLength; + this.ensureCapacity(length); + new Uint8Array(this.buffer).set(new Uint8Array(byteArray), this.writeOffset); + this.writeOffset += length; + } + + toBytes(): ArrayBuffer { + const result = new ArrayBuffer(this.writeOffset); + new Uint8Array(result).set(new Uint8Array(this.buffer.slice(0, this.writeOffset))); + return result; + } + + writeBoolean(value: boolean): void { + if (!(value === true || value === false)) { + throw new Error('value must be true of false'); + } + this.ensureCapacity(1); + if (value === true) { + this.bufferView.setInt8(this.writeOffset, 1); + } else { + this.bufferView.setInt8(this.writeOffset, 0); + } + this.writeOffset++; + } + + readBoolean(): boolean { + const value = this.bufferView.getInt8(this.readOffset); + this.readOffset++; + return (value === 1); + } + + writeByte(value: number): void { + this.ensureCapacity(1); + this.bufferView.setInt8(this.writeOffset, value); + this.writeOffset++; + } + + readByte(): number { + const value = this.bufferView.getInt8(this.readOffset); + this.readOffset++; + return value; + } + + writeShort(value: number): void { + if (!(minShort <= value && value <= maxShort)) { + throw new Error('value must range between minShort:-32768 and maxShort:32767'); + } + this.ensureCapacity(2); + this.bufferView.setInt16(this.writeOffset, value); + this.writeOffset += 2; + } + + readShort(): number { + const value = this.bufferView.getInt16(this.readOffset); + this.readOffset += 2; + return value; + } + + writeRawInt(value: number): void { + if (!(minInt <= value && value <= maxInt)) { + throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); + } + this.ensureCapacity(4); + this.bufferView.setInt32(this.writeOffset, value); + this.writeOffset += 4; + } + + readRawInt(): number { + const value = this.bufferView.getInt32(this.readOffset); + this.readOffset += 4; + return value; + } + + writeInt(value: number): void { + if (!(minInt <= value && value <= maxInt)) { + throw new Error('value must range between minInt:-2147483648 and maxInt:2147483647'); + } + this.ensureCapacity(5); + + value = encodeZigzagInt(value); + + if (value >>> 7 === 0) { + this.writeByte(value); + return; + } + + if (value >>> 14 === 0) { + this.writeByte((value & 0x7F) | 0x80); + this.writeByte((value >>> 7)); + return; + } + + if (value >>> 21 === 0) { + this.writeByte((value & 0x7F) | 0x80); + this.writeByte((value >>> 7 | 0x80)); + this.writeByte(value >>> 14); + return; + } + + if (value >>> 28 === 0) { + this.writeByte((value & 0x7F) | 0x80); + this.writeByte((value >>> 7 | 0x80)); + this.writeByte((value >>> 14 | 0x80)); + this.writeByte(value >>> 21); + return; + } + + this.writeByte((value & 0x7F) | 0x80); + this.writeByte((value >>> 7 | 0x80)); + this.writeByte((value >>> 14 | 0x80)); + this.writeByte((value >>> 21 | 0x80)); + this.writeByte(value >>> 28); + } + + readInt(): number { + let b = this.readByte(); + let value = b & 0x7F; + if ((b & 0x80) !== 0) { + b = this.readByte(); + value |= (b & 0x7F) << 7; + if ((b & 0x80) !== 0) { + b = this.readByte(); + value |= (b & 0x7F) << 14; + if ((b & 0x80) !== 0) { + b = this.readByte(); + value |= (b & 0x7F) << 21; + if ((b & 0x80) !== 0) { + b = this.readByte(); + value |= (b & 0x7F) << 28; + } + } + } + } + + return decodeZigzagInt(value); + } + + writeLong(value: number): void { + if (value === null || value === undefined) { + throw new Error('value must not be null'); + } + this.ensureCapacity(9); + + Longbits.writeInt64(this, value); + } + + readLong(): number { + const buffer = new ArrayBuffer(9); + const bufferView = new DataView(buffer, 0, buffer.byteLength); + + let count = 0; + let b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + if ((b & 0x80) !== 0) { + b = this.readByte(); + bufferView.setUint8(count++, b); + } + } + } + } + } + } + } + } + return Longbits.readInt64(new Uint8Array(buffer.slice(0, count))).toString(); + } + + writeFloat(value: number): void { + if (value === null || value === undefined) { + throw new Error('value must not be null'); + } + this.ensureCapacity(4); + this.bufferView.setFloat32(this.writeOffset, value); + this.writeOffset += 4; + } + + readFloat(): number { + const value = this.bufferView.getFloat32(this.readOffset); + this.readOffset += 4; + return value; + } + + writeDouble(value: number): void { + if (value === null || value === undefined) { + throw new Error('value must not be null'); + } + this.ensureCapacity(8); + this.bufferView.setFloat64(this.writeOffset, value); + this.writeOffset += 8; + } + + readDouble(): number { + const value = this.bufferView.getFloat64(this.readOffset); + this.readOffset += 8; + return value; + } + + writeChar(value: string): void { + if (value === null || value === undefined || value.length === 0) { + this.writeString(empty_str); + return; + } + this.writeString(value.charAt(0)); + } + + readChar(): string { + return this.readString(); + } + + writeString(value: string): void { + if (value === null || value === undefined || value.trim().length === 0) { + this.writeInt(0); + return; + } + + const uint8Array = encoder.encode(value); + + this.ensureCapacity(5 + uint8Array.length); + + this.writeInt(uint8Array.length); + uint8Array.forEach((value: number) => this.writeByte(value)); + } + + readString(): string { + const length = this.readInt(); + if (length <= 0) { + return empty_str; + } + const uint8Array = new Uint8Array(this.buffer.slice(this.readOffset, this.readOffset + length)); + const value = decoder.decode(uint8Array); + this.readOffset += length; + return value; + } + + writePacketFlag(value: any): boolean { + const flag = (value === null) || (value === undefined); + this.writeBoolean(!flag); + return flag; + }; + + writePacket(packet: any, protocolId: number) { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + protocolRegistration.write(this, packet); + }; + + readPacket(protocolId: number): any { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + return protocolRegistration.read(this); + }; + + writeBooleanArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + readBooleanArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readBoolean()); + } + } + return array; + }; + + writeByteArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeByte(element); + }); + } + }; + + readByteArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readByte()); + } + } + return array; + }; + + writeShortArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeShort(element); + }); + } + }; + + readShortArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readShort()); + } + } + return array; + }; + + writeIntArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeInt(element); + }); + } + }; + + readIntArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readInt()); + } + } + return array; + }; + + writeLongArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeLong(element); + }); + } + }; + + readLongArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readLong()); + } + } + return array; + }; + + writeFloatArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeFloat(element); + }); + } + }; + + readFloatArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readFloat()); + } + } + return array; + }; + + writeDoubleArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeDouble(element); + }); + } + }; + + readDoubleArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readDouble()); + } + } + return array; + }; + + writeStringArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeString(element); + }); + } + }; + + readStringArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readString()); + } + } + return array; + }; + + writeCharArray(array: Array | null) { + if (array === null) { + this.writeInt(0); + } else { + this.writeInt(array.length); + array.forEach(element => { + this.writeChar(element); + }); + } + }; + + readCharArray(): any { + const array = []; + const length = this.readInt(); + if (length > 0) { + for (let index = 0; index < length; index++) { + array.push(this.readChar()); + } + } + return array; + }; + + writePacketArray(array: Array | null, protocolId: number) { + if (array === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(array.length); + array.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + readPacketArray(protocolId: number): any { + 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; + }; + + // ---------------------------------------------list------------------------------------------- + writeBooleanList(list: any) { + this.writeBooleanArray(list); + }; + + readBooleanList(): any { + return this.readBooleanArray(); + }; + + writeByteList(list: any) { + this.writeByteArray(list); + }; + + readByteList(): any { + return this.readByteArray(); + }; + + writeShortList(list: any) { + this.writeShortArray(list); + }; + + readShortList(): any { + return this.readShortArray(); + }; + + writeIntList(list: any) { + this.writeIntArray(list); + }; + + readIntList(): any { + return this.readIntArray(); + }; + + writeLongList(list: any) { + this.writeLongArray(list); + }; + + readLongList(): any { + return this.readLongArray(); + }; + + writeFloatList(list: any) { + this.writeFloatArray(list); + }; + + readFloatList(): any { + return this.readFloatArray(); + }; + + writeDoubleList(list: any) { + this.writeDoubleArray(list); + }; + + readDoubleList(): any { + return this.readDoubleArray(); + }; + + writeStringList(list: any) { + this.writeStringArray(list); + }; + + readStringList(): any { + return this.readStringArray(); + }; + + writeCharList(list: any) { + this.writeCharArray(list); + }; + + readCharList(): any { + return this.readCharArray(); + }; + + writePacketList(list: any, protocolId: number) { + this.writePacketArray(list, protocolId); + }; + + readPacketList(protocolId: number): any { + return this.readPacketArray(protocolId); + }; + + // ---------------------------------------------set------------------------------------------- + writeBooleanSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeBoolean(element); + }); + } + }; + + readBooleanSet(): any { + return new Set(this.readBooleanArray()); + }; + + writeByteSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeByte(element); + }); + } + }; + + readByteSet(): any { + return new Set(this.readByteArray()); + }; + + writeShortSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeShort(element); + }); + } + }; + + readShortSet(): any { + return new Set(this.readShortArray()); + }; + + writeIntSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeInt(element); + }); + } + }; + + readIntSet(): any { + return new Set(this.readIntArray()); + }; + + writeLongSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeLong(element); + }); + } + }; + + readLongSet(): any { + return new Set(this.readLongArray()); + }; + + writeFloatSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeFloat(element); + }); + } + }; + + readFloatSet(): any { + return new Set(this.readFloatArray()); + }; + + writeDoubleSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeDouble(element); + }); + } + }; + + readDoubleSet(): any { + return new Set(this.readDoubleArray()); + }; + + writeStringSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeString(element); + }); + } + }; + + readStringSet(): any { + return new Set(this.readStringArray()); + }; + + writeCharSet(set: Set | null) { + if (set === null) { + this.writeInt(0); + } else { + this.writeInt(set.size); + set.forEach(element => { + this.writeChar(element); + }); + } + }; + + readCharSet(): any { + return new Set(this.readCharArray()); + }; + + writePacketSet(set: Set | null, protocolId: number) { + if (set === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(set.size); + set.forEach(element => { + protocolRegistration.write(this, element); + }); + } + }; + + readPacketSet(protocolId: number): any { + return new Set(this.readPacketArray(protocolId)); + }; + + // ---------------------------------------------map------------------------------------------- + writeIntIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeInt(value); + }); + } + }; + + readIntIntMap(): any { + 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; + }; + + writeIntLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeLong(value); + }); + } + }; + + readIntLongMap(): any { + 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; + }; + + writeIntStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + this.writeString(value); + }); + } + }; + + readIntStringMap(): any { + 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; + }; + + writeIntPacketMap(map: Map | null, protocolId: number) { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeInt(key); + protocolRegistration.write(this, value); + }); + } + }; + + readIntPacketMap(protocolId: number): any { + 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; + }; + + writeLongIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeInt(value); + }); + } + }; + + readLongIntMap(): any { + 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; + }; + + writeLongLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeLong(value); + }); + } + }; + + readLongLongMap(): any { + 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; + }; + + writeLongStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + this.writeString(value); + }); + } + }; + + readLongStringMap(): any { + 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; + }; + + writeLongPacketMap(map: Map | null, protocolId: number): any { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeLong(key); + protocolRegistration.write(this, value); + }); + } + }; + + readLongPacketMap(protocolId: number): any { + 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; + }; + + writeStringIntMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeInt(value); + }); + } + }; + + readStringIntMap(): any { + 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; + }; + + writeStringLongMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeLong(value); + }); + } + }; + + readStringLongMap(): any { + 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; + }; + + writeStringStringMap(map: Map | null) { + if (map === null) { + this.writeInt(0); + } else { + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + this.writeString(value); + }); + } + }; + + readStringStringMap(): any { + 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; + }; + + writeStringPacketMap(map: Map | null, protocolId: number) { + if (map === null) { + this.writeInt(0); + } else { + const protocolRegistration = ProtocolManager.getProtocol(protocolId); + this.writeInt(map.size); + map.forEach((value, key) => { + this.writeString(key); + protocolRegistration.write(this, value); + }); + } + }; + + readStringPacketMap(protocolId: number): any { + 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/typescript/zfoo/buffer/long.js b/protocol/src/test/typescript/zfoo/buffer/long.js new file mode 100644 index 00000000..31a8e6d7 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/buffer/long.js @@ -0,0 +1,1325 @@ +/* eslint-disable */ +// from https://github.com/dcodeIO/long.js/blob/master/src/long.js +module.exports = Long; + +/** + * wasm optimizations, to do native i64 multiplication and divide + */ +var wasm = null; + +try { + wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11 + ])), {}).exports; +} catch (e) { + // no wasm support :( +} + +/** + * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers. + * See the from* functions below for more convenient ways of constructing Longs. + * @exports Long + * @class A Long class for representing a 64 bit two's-complement integer value. + * @param {number} low The low (signed) 32 bits of the long + * @param {number} high The high (signed) 32 bits of the long + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @constructor + */ +function Long(low, high, unsigned) { + + /** + * The low 32 bits as a signed value. + * @type {number} + */ + this.low = low | 0; + + /** + * The high 32 bits as a signed value. + * @type {number} + */ + this.high = high | 0; + + /** + * Whether unsigned or not. + * @type {boolean} + */ + this.unsigned = !!unsigned; +} + +// The internal representation of a long is the two given signed, 32-bit values. +// We use 32-bit pieces because these are the size of integers on which +// Javascript performs bit-operations. For operations like addition and +// multiplication, we split each number into 16 bit pieces, which can easily be +// multiplied within Javascript's floating-point representation without overflow +// or change in sign. +// +// In the algorithms below, we frequently reduce the negative case to the +// positive case by negating the input(s) and then post-processing the result. +// Note that we must ALWAYS check specially whether those values are MIN_VALUE +// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as +// a positive number, it overflows back into a negative). Not handling this +// case would often result in infinite recursion. +// +// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from* +// methods on which they depend. + +/** + * An indicator used to reliably determine if an object is a Long or not. + * @type {boolean} + * @const + * @private + */ +Long.prototype.__isLong__; + +Object.defineProperty(Long.prototype, "__isLong__", {value: true}); + +/** + * @function + * @param {*} obj Object + * @returns {boolean} + * @inner + */ +function isLong(obj) { + return (obj && obj["__isLong__"]) === true; +} + +/** + * Tests if the specified object is a Long. + * @function + * @param {*} obj Object + * @returns {boolean} + */ +Long.isLong = isLong; + +/** + * A cache of the Long representations of small integer values. + * @type {!Object} + * @inner + */ +var INT_CACHE = {}; + +/** + * A cache of the Long representations of small unsigned integer values. + * @type {!Object} + * @inner + */ +var UINT_CACHE = {}; + +/** + * @param {number} value + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ +function fromInt(value, unsigned) { + var obj, cachedObj, cache; + if (unsigned) { + value >>>= 0; + if (cache = (0 <= value && value < 256)) { + cachedObj = UINT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true); + if (cache) + UINT_CACHE[value] = obj; + return obj; + } else { + value |= 0; + if (cache = (-128 <= value && value < 128)) { + cachedObj = INT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = fromBits(value, value < 0 ? -1 : 0, false); + if (cache) + INT_CACHE[value] = obj; + return obj; + } +} + +/** + * Returns a Long representing the given 32 bit integer value. + * @function + * @param {number} value The 32 bit integer in question + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {!Long} The corresponding Long value + */ +Long.fromInt = fromInt; + +/** + * @param {number} value + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ +function fromNumber(value, unsigned) { + if (isNaN(value)) + return unsigned ? UZERO : ZERO; + if (unsigned) { + if (value < 0) + return UZERO; + if (value >= TWO_PWR_64_DBL) + return MAX_UNSIGNED_VALUE; + } else { + if (value <= -TWO_PWR_63_DBL) + return MIN_VALUE; + if (value + 1 >= TWO_PWR_63_DBL) + return MAX_VALUE; + } + if (value < 0) + return fromNumber(-value, unsigned).neg(); + return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned); +} + +/** + * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned. + * @function + * @param {number} value The number in question + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {!Long} The corresponding Long value + */ +Long.fromNumber = fromNumber; + +/** + * @param {number} lowBits + * @param {number} highBits + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ +function fromBits(lowBits, highBits, unsigned) { + return new Long(lowBits, highBits, unsigned); +} + +/** + * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is + * assumed to use 32 bits. + * @function + * @param {number} lowBits The low 32 bits + * @param {number} highBits The high 32 bits + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {!Long} The corresponding Long value + */ +Long.fromBits = fromBits; + +/** + * @function + * @param {number} base + * @param {number} exponent + * @returns {number} + * @inner + */ +var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4) + +/** + * @param {string} str + * @param {(boolean|number)=} unsigned + * @param {number=} radix + * @returns {!Long} + * @inner + */ +function fromString(str, unsigned, radix) { + if (str.length === 0) + throw Error('empty string'); + if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") + return ZERO; + if (typeof unsigned === 'number') { + // For goog.math.long compatibility + radix = unsigned, + unsigned = false; + } else { + unsigned = !!unsigned; + } + radix = radix || 10; + if (radix < 2 || 36 < radix) + throw RangeError('radix'); + + var p; + if ((p = str.indexOf('-')) > 0) + throw Error('interior hyphen'); + else if (p === 0) { + return fromString(str.substring(1), unsigned, radix).neg(); + } + + // Do several (8) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = fromNumber(pow_dbl(radix, 8)); + + var result = ZERO; + for (var i = 0; i < str.length; i += 8) { + var size = Math.min(8, str.length - i), + value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + var power = fromNumber(pow_dbl(radix, size)); + result = result.mul(power).add(fromNumber(value)); + } else { + result = result.mul(radixToPower); + result = result.add(fromNumber(value)); + } + } + result.unsigned = unsigned; + return result; +} + +/** + * Returns a Long representation of the given string, written using the specified radix. + * @function + * @param {string} str The textual representation of the Long + * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed + * @param {number=} radix The radix in which the text is written (2-36), defaults to 10 + * @returns {!Long} The corresponding Long value + */ +Long.fromString = fromString; + +/** + * @function + * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val + * @param {boolean=} unsigned + * @returns {!Long} + * @inner + */ +function fromValue(val, unsigned) { + if (typeof val === 'number') + return fromNumber(val, unsigned); + if (typeof val === 'string') + return fromString(val, unsigned); + // Throws for non-objects, converts non-instanceof Long: + return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned); +} + +/** + * Converts the specified value to a Long using the appropriate from* function for its type. + * @function + * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {!Long} + */ +Long.fromValue = fromValue; + +// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be +// no runtime penalty for these. + +/** + * @type {number} + * @const + * @inner + */ +var TWO_PWR_16_DBL = 1 << 16; + +/** + * @type {number} + * @const + * @inner + */ +var TWO_PWR_24_DBL = 1 << 24; + +/** + * @type {number} + * @const + * @inner + */ +var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; + +/** + * @type {number} + * @const + * @inner + */ +var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; + +/** + * @type {number} + * @const + * @inner + */ +var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; + +/** + * @type {!Long} + * @const + * @inner + */ +var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL); + +/** + * @type {!Long} + * @inner + */ +var ZERO = fromInt(0); + +/** + * Signed zero. + * @type {!Long} + */ +Long.ZERO = ZERO; + +/** + * @type {!Long} + * @inner + */ +var UZERO = fromInt(0, true); + +/** + * Unsigned zero. + * @type {!Long} + */ +Long.UZERO = UZERO; + +/** + * @type {!Long} + * @inner + */ +var ONE = fromInt(1); + +/** + * Signed one. + * @type {!Long} + */ +Long.ONE = ONE; + +/** + * @type {!Long} + * @inner + */ +var UONE = fromInt(1, true); + +/** + * Unsigned one. + * @type {!Long} + */ +Long.UONE = UONE; + +/** + * @type {!Long} + * @inner + */ +var NEG_ONE = fromInt(-1); + +/** + * Signed negative one. + * @type {!Long} + */ +Long.NEG_ONE = NEG_ONE; + +/** + * @type {!Long} + * @inner + */ +var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false); + +/** + * Maximum signed value. + * @type {!Long} + */ +Long.MAX_VALUE = MAX_VALUE; + +/** + * @type {!Long} + * @inner + */ +var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true); + +/** + * Maximum unsigned value. + * @type {!Long} + */ +Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE; + +/** + * @type {!Long} + * @inner + */ +var MIN_VALUE = fromBits(0, 0x80000000 | 0, false); + +/** + * Minimum signed value. + * @type {!Long} + */ +Long.MIN_VALUE = MIN_VALUE; + +/** + * @alias Long.prototype + * @inner + */ +var LongPrototype = Long.prototype; + +/** + * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer. + * @returns {number} + */ +LongPrototype.toInt = function toInt() { + return this.unsigned ? this.low >>> 0 : this.low; +}; + +/** + * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa). + * @returns {number} + */ +LongPrototype.toNumber = function toNumber() { + if (this.unsigned) + return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0); + return this.high * TWO_PWR_32_DBL + (this.low >>> 0); +}; + +/** + * Converts the Long to a string written in the specified radix. + * @param {number=} radix Radix (2-36), defaults to 10 + * @returns {string} + * @override + * @throws {RangeError} If `radix` is out of range + */ +LongPrototype.toString = function toString(radix) { + radix = radix || 10; + if (radix < 2 || 36 < radix) + throw RangeError('radix'); + if (this.isZero()) + return '0'; + if (this.isNegative()) { // Unsigned Longs are never negative + if (this.eq(MIN_VALUE)) { + // We need to change the Long value before it can be negated, so we remove + // the bottom-most digit in this base and then recurse to do the rest. + var radixLong = fromNumber(radix), + div = this.div(radixLong), + rem1 = div.mul(radixLong).sub(this); + return div.toString(radix) + rem1.toInt().toString(radix); + } else + return '-' + this.neg().toString(radix); + } + + // Do several (6) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), + rem = this; + var result = ''; + while (true) { + var remDiv = rem.div(radixToPower), + intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, + digits = intval.toString(radix); + rem = remDiv; + if (rem.isZero()) + return digits + result; + else { + while (digits.length < 6) + digits = '0' + digits; + result = '' + digits + result; + } + } +}; + +/** + * Gets the high 32 bits as a signed integer. + * @returns {number} Signed high bits + */ +LongPrototype.getHighBits = function getHighBits() { + return this.high; +}; + +/** + * Gets the high 32 bits as an unsigned integer. + * @returns {number} Unsigned high bits + */ +LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() { + return this.high >>> 0; +}; + +/** + * Gets the low 32 bits as a signed integer. + * @returns {number} Signed low bits + */ +LongPrototype.getLowBits = function getLowBits() { + return this.low; +}; + +/** + * Gets the low 32 bits as an unsigned integer. + * @returns {number} Unsigned low bits + */ +LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() { + return this.low >>> 0; +}; + +/** + * Gets the number of bits needed to represent the absolute value of this Long. + * @returns {number} + */ +LongPrototype.getNumBitsAbs = function getNumBitsAbs() { + if (this.isNegative()) // Unsigned Longs are never negative + return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); + var val = this.high != 0 ? this.high : this.low; + for (var bit = 31; bit > 0; bit--) + if ((val & (1 << bit)) != 0) + break; + return this.high != 0 ? bit + 33 : bit + 1; +}; + +/** + * Tests if this Long's value equals zero. + * @returns {boolean} + */ +LongPrototype.isZero = function isZero() { + return this.high === 0 && this.low === 0; +}; + +/** + * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}. + * @returns {boolean} + */ +LongPrototype.eqz = LongPrototype.isZero; + +/** + * Tests if this Long's value is negative. + * @returns {boolean} + */ +LongPrototype.isNegative = function isNegative() { + return !this.unsigned && this.high < 0; +}; + +/** + * Tests if this Long's value is positive. + * @returns {boolean} + */ +LongPrototype.isPositive = function isPositive() { + return this.unsigned || this.high >= 0; +}; + +/** + * Tests if this Long's value is odd. + * @returns {boolean} + */ +LongPrototype.isOdd = function isOdd() { + return (this.low & 1) === 1; +}; + +/** + * Tests if this Long's value is even. + * @returns {boolean} + */ +LongPrototype.isEven = function isEven() { + return (this.low & 1) === 0; +}; + +/** + * Tests if this Long's value equals the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.equals = function equals(other) { + if (!isLong(other)) + other = fromValue(other); + if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1) + return false; + return this.high === other.high && this.low === other.low; +}; + +/** + * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.eq = LongPrototype.equals; + +/** + * Tests if this Long's value differs from the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.notEquals = function notEquals(other) { + return !this.eq(/* validates */ other); +}; + +/** + * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.neq = LongPrototype.notEquals; + +/** + * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.ne = LongPrototype.notEquals; + +/** + * Tests if this Long's value is less than the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.lessThan = function lessThan(other) { + return this.comp(/* validates */ other) < 0; +}; + +/** + * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.lt = LongPrototype.lessThan; + +/** + * Tests if this Long's value is less than or equal the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) { + return this.comp(/* validates */ other) <= 0; +}; + +/** + * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.lte = LongPrototype.lessThanOrEqual; + +/** + * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.le = LongPrototype.lessThanOrEqual; + +/** + * Tests if this Long's value is greater than the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.greaterThan = function greaterThan(other) { + return this.comp(/* validates */ other) > 0; +}; + +/** + * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.gt = LongPrototype.greaterThan; + +/** + * Tests if this Long's value is greater than or equal the specified's. + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) { + return this.comp(/* validates */ other) >= 0; +}; + +/** + * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.gte = LongPrototype.greaterThanOrEqual; + +/** + * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}. + * @function + * @param {!Long|number|string} other Other value + * @returns {boolean} + */ +LongPrototype.ge = LongPrototype.greaterThanOrEqual; + +/** + * Compares this Long's value with the specified's. + * @param {!Long|number|string} other Other value + * @returns {number} 0 if they are the same, 1 if the this is greater and -1 + * if the given one is greater + */ +LongPrototype.compare = function compare(other) { + if (!isLong(other)) + other = fromValue(other); + if (this.eq(other)) + return 0; + var thisNeg = this.isNegative(), + otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) + return -1; + if (!thisNeg && otherNeg) + return 1; + // At this point the sign bits are the same + if (!this.unsigned) + return this.sub(other).isNegative() ? -1 : 1; + // Both are positive if at least one is unsigned + return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1; +}; + +/** + * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}. + * @function + * @param {!Long|number|string} other Other value + * @returns {number} 0 if they are the same, 1 if the this is greater and -1 + * if the given one is greater + */ +LongPrototype.comp = LongPrototype.compare; + +/** + * Negates this Long's value. + * @returns {!Long} Negated Long + */ +LongPrototype.negate = function negate() { + if (!this.unsigned && this.eq(MIN_VALUE)) + return MIN_VALUE; + return this.not().add(ONE); +}; + +/** + * Negates this Long's value. This is an alias of {@link Long#negate}. + * @function + * @returns {!Long} Negated Long + */ +LongPrototype.neg = LongPrototype.negate; + +/** + * Returns the sum of this and the specified Long. + * @param {!Long|number|string} addend Addend + * @returns {!Long} Sum + */ +LongPrototype.add = function add(addend) { + if (!isLong(addend)) + addend = fromValue(addend); + + // Divide each number into 4 chunks of 16 bits, and then sum the chunks. + + var a48 = this.high >>> 16; + var a32 = this.high & 0xFFFF; + var a16 = this.low >>> 16; + var a00 = this.low & 0xFFFF; + + var b48 = addend.high >>> 16; + var b32 = addend.high & 0xFFFF; + var b16 = addend.low >>> 16; + var b00 = addend.low & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 + b48; + c48 &= 0xFFFF; + return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); +}; + +/** + * Returns the difference of this and the specified Long. + * @param {!Long|number|string} subtrahend Subtrahend + * @returns {!Long} Difference + */ +LongPrototype.subtract = function subtract(subtrahend) { + if (!isLong(subtrahend)) + subtrahend = fromValue(subtrahend); + return this.add(subtrahend.neg()); +}; + +/** + * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}. + * @function + * @param {!Long|number|string} subtrahend Subtrahend + * @returns {!Long} Difference + */ +LongPrototype.sub = LongPrototype.subtract; + +/** + * Returns the product of this and the specified Long. + * @param {!Long|number|string} multiplier Multiplier + * @returns {!Long} Product + */ +LongPrototype.multiply = function multiply(multiplier) { + if (this.isZero()) + return ZERO; + if (!isLong(multiplier)) + multiplier = fromValue(multiplier); + + // use wasm support if present + if (wasm) { + var low = wasm.mul(this.low, + this.high, + multiplier.low, + multiplier.high); + return fromBits(low, wasm.get_high(), this.unsigned); + } + + if (multiplier.isZero()) + return ZERO; + if (this.eq(MIN_VALUE)) + return multiplier.isOdd() ? MIN_VALUE : ZERO; + if (multiplier.eq(MIN_VALUE)) + return this.isOdd() ? MIN_VALUE : ZERO; + + if (this.isNegative()) { + if (multiplier.isNegative()) + return this.neg().mul(multiplier.neg()); + else + return this.neg().mul(multiplier).neg(); + } else if (multiplier.isNegative()) + return this.mul(multiplier.neg()).neg(); + + // If both longs are small, use float multiplication + if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) + return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); + + // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. + // We can skip products that would overflow. + + var a48 = this.high >>> 16; + var a32 = this.high & 0xFFFF; + var a16 = this.low >>> 16; + var a00 = this.low & 0xFFFF; + + var b48 = multiplier.high >>> 16; + var b32 = multiplier.high & 0xFFFF; + var b16 = multiplier.low >>> 16; + var b00 = multiplier.low & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 0xFFFF; + return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned); +}; + +/** + * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}. + * @function + * @param {!Long|number|string} multiplier Multiplier + * @returns {!Long} Product + */ +LongPrototype.mul = LongPrototype.multiply; + +/** + * Returns this Long divided by the specified. The result is signed if this Long is signed or + * unsigned if this Long is unsigned. + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Quotient + */ +LongPrototype.divide = function divide(divisor) { + if (!isLong(divisor)) + divisor = fromValue(divisor); + if (divisor.isZero()) + throw Error('division by zero'); + + // use wasm support if present + if (wasm) { + // guard against signed division overflow: the largest + // negative number / -1 would be 1 larger than the largest + // positive number, due to two's complement. + if (!this.unsigned && + this.high === -0x80000000 && + divisor.low === -1 && divisor.high === -1) { + // be consistent with non-wasm code path + return this; + } + var low = (this.unsigned ? wasm.div_u : wasm.div_s)( + this.low, + this.high, + divisor.low, + divisor.high + ); + return fromBits(low, wasm.get_high(), this.unsigned); + } + + if (this.isZero()) + return this.unsigned ? UZERO : ZERO; + var approx, rem, res; + if (!this.unsigned) { + // This section is only relevant for signed longs and is derived from the + // closure library as a whole. + if (this.eq(MIN_VALUE)) { + if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) + return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE + else if (divisor.eq(MIN_VALUE)) + return ONE; + else { + // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. + var halfThis = this.shr(1); + approx = halfThis.div(divisor).shl(1); + if (approx.eq(ZERO)) { + return divisor.isNegative() ? ONE : NEG_ONE; + } else { + rem = this.sub(divisor.mul(approx)); + res = approx.add(rem.div(divisor)); + return res; + } + } + } else if (divisor.eq(MIN_VALUE)) + return this.unsigned ? UZERO : ZERO; + if (this.isNegative()) { + if (divisor.isNegative()) + return this.neg().div(divisor.neg()); + return this.neg().div(divisor).neg(); + } else if (divisor.isNegative()) + return this.div(divisor.neg()).neg(); + res = ZERO; + } else { + // The algorithm below has not been made for unsigned longs. It's therefore + // required to take special care of the MSB prior to running it. + if (!divisor.unsigned) + divisor = divisor.toUnsigned(); + if (divisor.gt(this)) + return UZERO; + if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true + return UONE; + res = UZERO; + } + + // Repeat the following until the remainder is less than other: find a + // floating-point that approximates remainder / other *from below*, add this + // into the result, and subtract it from the remainder. It is critical that + // the approximate value is less than or equal to the real value so that the + // remainder never becomes negative. + rem = this; + while (rem.gte(divisor)) { + // Approximate the result of division. This may be a little greater or + // smaller than the actual value. + approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); + + // We will tweak the approximate result by changing it in the 48-th digit or + // the smallest non-fractional digit, whichever is larger. + var log2 = Math.ceil(Math.log(approx) / Math.LN2), + delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), + + // Decrease the approximation until it is smaller than the remainder. Note + // that if it is too large, the product overflows and is negative. + approxRes = fromNumber(approx), + approxRem = approxRes.mul(divisor); + while (approxRem.isNegative() || approxRem.gt(rem)) { + approx -= delta; + approxRes = fromNumber(approx, this.unsigned); + approxRem = approxRes.mul(divisor); + } + + // We know the answer can't be zero... and actually, zero would cause + // infinite recursion since we would make no progress. + if (approxRes.isZero()) + approxRes = ONE; + + res = res.add(approxRes); + rem = rem.sub(approxRem); + } + return res; +}; + +/** + * Returns this Long divided by the specified. This is an alias of {@link Long#divide}. + * @function + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Quotient + */ +LongPrototype.div = LongPrototype.divide; + +/** + * Returns this Long modulo the specified. + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Remainder + */ +LongPrototype.modulo = function modulo(divisor) { + if (!isLong(divisor)) + divisor = fromValue(divisor); + + // use wasm support if present + if (wasm) { + var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)( + this.low, + this.high, + divisor.low, + divisor.high + ); + return fromBits(low, wasm.get_high(), this.unsigned); + } + + return this.sub(this.div(divisor).mul(divisor)); +}; + +/** + * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. + * @function + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Remainder + */ +LongPrototype.mod = LongPrototype.modulo; + +/** + * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}. + * @function + * @param {!Long|number|string} divisor Divisor + * @returns {!Long} Remainder + */ +LongPrototype.rem = LongPrototype.modulo; + +/** + * Returns the bitwise NOT of this Long. + * @returns {!Long} + */ +LongPrototype.not = function not() { + return fromBits(~this.low, ~this.high, this.unsigned); +}; + +/** + * Returns the bitwise AND of this Long and the specified. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ +LongPrototype.and = function and(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low & other.low, this.high & other.high, this.unsigned); +}; + +/** + * Returns the bitwise OR of this Long and the specified. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ +LongPrototype.or = function or(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low | other.low, this.high | other.high, this.unsigned); +}; + +/** + * Returns the bitwise XOR of this Long and the given one. + * @param {!Long|number|string} other Other Long + * @returns {!Long} + */ +LongPrototype.xor = function xor(other) { + if (!isLong(other)) + other = fromValue(other); + return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); +}; + +/** + * Returns this Long with bits shifted to the left by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shiftLeft = function shiftLeft(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned); + else + return fromBits(0, this.low << (numBits - 32), this.unsigned); +}; + +/** + * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shl = LongPrototype.shiftLeft; + +/** + * Returns this Long with bits arithmetically shifted to the right by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shiftRight = function shiftRight(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned); + else + return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned); +}; + +/** + * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shr = LongPrototype.shiftRight; + +/** + * Returns this Long with bits logically shifted to the right by the given amount. + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { + if (isLong(numBits)) + numBits = numBits.toInt(); + numBits &= 63; + if (numBits === 0) + return this; + else { + var high = this.high; + if (numBits < 32) { + var low = this.low; + return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned); + } else if (numBits === 32) + return fromBits(high, 0, this.unsigned); + else + return fromBits(high >>> (numBits - 32), 0, this.unsigned); + } +}; + +/** + * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shru = LongPrototype.shiftRightUnsigned; + +/** + * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}. + * @function + * @param {number|!Long} numBits Number of bits + * @returns {!Long} Shifted Long + */ +LongPrototype.shr_u = LongPrototype.shiftRightUnsigned; + +/** + * Converts this Long to signed. + * @returns {!Long} Signed long + */ +LongPrototype.toSigned = function toSigned() { + if (!this.unsigned) + return this; + return fromBits(this.low, this.high, false); +}; + +/** + * Converts this Long to unsigned. + * @returns {!Long} Unsigned long + */ +LongPrototype.toUnsigned = function toUnsigned() { + if (this.unsigned) + return this; + return fromBits(this.low, this.high, true); +}; + +/** + * Converts this Long to its byte representation. + * @param {boolean=} le Whether little or big endian, defaults to big endian + * @returns {!Array.} Byte representation + */ +LongPrototype.toBytes = function toBytes(le) { + return le ? this.toBytesLE() : this.toBytesBE(); +}; + +/** + * Converts this Long to its little endian byte representation. + * @returns {!Array.} Little endian byte representation + */ +LongPrototype.toBytesLE = function toBytesLE() { + var hi = this.high, + lo = this.low; + return [ + lo & 0xff, + lo >>> 8 & 0xff, + lo >>> 16 & 0xff, + lo >>> 24, + hi & 0xff, + hi >>> 8 & 0xff, + hi >>> 16 & 0xff, + hi >>> 24 + ]; +}; + +/** + * Converts this Long to its big endian byte representation. + * @returns {!Array.} Big endian byte representation + */ +LongPrototype.toBytesBE = function toBytesBE() { + var hi = this.high, + lo = this.low; + return [ + hi >>> 24, + hi >>> 16 & 0xff, + hi >>> 8 & 0xff, + hi & 0xff, + lo >>> 24, + lo >>> 16 & 0xff, + lo >>> 8 & 0xff, + lo & 0xff + ]; +}; + +/** + * Creates a Long from its byte representation. + * @param {!Array.} bytes Byte representation + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @param {boolean=} le Whether little or big endian, defaults to big endian + * @returns {Long} The corresponding Long value + */ +Long.fromBytes = function fromBytes(bytes, unsigned, le) { + return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned); +}; + +/** + * Creates a Long from its little endian byte representation. + * @param {!Array.} bytes Little endian byte representation + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {Long} The corresponding Long value + */ +Long.fromBytesLE = function fromBytesLE(bytes, unsigned) { + return new Long( + bytes[0] | + bytes[1] << 8 | + bytes[2] << 16 | + bytes[3] << 24, + bytes[4] | + bytes[5] << 8 | + bytes[6] << 16 | + bytes[7] << 24, + unsigned + ); +}; + +/** + * Creates a Long from its big endian byte representation. + * @param {!Array.} bytes Big endian byte representation + * @param {boolean=} unsigned Whether unsigned or not, defaults to signed + * @returns {Long} The corresponding Long value + */ +Long.fromBytesBE = function fromBytesBE(bytes, unsigned) { + return new Long( + bytes[4] << 24 | + bytes[5] << 16 | + bytes[6] << 8 | + bytes[7], + bytes[0] << 24 | + bytes[1] << 16 | + bytes[2] << 8 | + bytes[3], + unsigned + ); +}; diff --git a/protocol/src/test/typescript/zfoo/buffer/longbits.js b/protocol/src/test/typescript/zfoo/buffer/longbits.js new file mode 100644 index 00000000..23f759ad --- /dev/null +++ b/protocol/src/test/typescript/zfoo/buffer/longbits.js @@ -0,0 +1,189 @@ +// from protobuf +const Long = require('./long.js') + +module.exports = LongBits; + +/** + * Constructs new long bits. + * @classdesc Helper class for working with the low and high bits of a 64 bit value. + * @memberof util + * @constructor + * @param {number} lo Low 32 bits, unsigned + * @param {number} hi High 32 bits, unsigned + */ +function LongBits(lo, hi) { + // note that the casts below are theoretically unnecessary as of today, but older statically + // generated converter code might still call the ctor with signed 32bits. kept for compat. + + /** + * Low bits. + * @type {number} + */ + this.lo = lo >>> 0; + + /** + * High bits. + * @type {number} + */ + this.hi = hi >>> 0; +} + +/** + * Zig-zag encodes this long bits. + * @returns {util.LongBits} `this` + */ +LongBits.prototype.zzEncode = function zzEncode() { + const mask = this.hi >> 31; + this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0; + this.lo = (this.lo << 1 ^ mask) >>> 0; + return this; +}; + +/** + * Zig-zag decodes this long bits. + * @returns {util.LongBits} `this` + */ +LongBits.prototype.zzDecode = function zzDecode() { + const mask = -(this.lo & 1); + this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0; + this.hi = (this.hi >>> 1 ^ mask) >>> 0; + return this; +}; + +/** + * Converts this long bits to a long. + * @param {boolean} [unsigned=false] Whether unsigned or not + * @returns {Long} Long + */ +LongBits.prototype.toLong = function toLong(unsigned) { + return new Long(this.lo | 0, this.hi | 0, Boolean(unsigned)); +}; + +/** + * Zero bits. + * @memberof util.LongBits + * @type {util.LongBits} + */ +const zero = LongBits.zero = new LongBits(0, 0); + +function from(value) { + if (typeof value === 'number') { + return fromNumber(value); + } + if (typeof value === 'string' || value instanceof String) { + value = Long.fromString(value); + } + return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero; +} + + +/** + * Constructs new long bits from the specified number. + * @param {number} value Value + * @returns {util.LongBits} Instance + */ +function fromNumber(value) { + if (value === 0) { + return zero; + } + const sign = value < 0; + if (sign) { + value = -value; + } + let lo = value >>> 0; + let hi = (value - lo) / 4294967296 >>> 0; + if (sign) { + hi = ~hi >>> 0; + lo = ~lo >>> 0; + if (++lo > 4294967295) { + lo = 0; + if (++hi > 4294967295) { + hi = 0; + } + } + } + return new LongBits(lo, hi); +} + +function writeVarint64(byteBuffer, value) { + let count = 0; + while (value.hi) { + byteBuffer.writeByte(value.lo & 127 | 128); + value.lo = (value.lo >>> 7 | value.hi << 25) >>> 0; + value.hi >>>= 7; + count = count + 7; + } + while (value.lo > 127) { + if (count >= 56) { + byteBuffer.writeByte(value.lo); + return; + } + byteBuffer.writeByte(value.lo & 127 | 128); + value.lo = value.lo >>> 7; + count = count + 7; + } + byteBuffer.writeByte(value.lo); +} + +function readLongVarint(buffer) { + // tends to deopt with local vars for octet etc. + const bits = new LongBits(0, 0); + let i = 0; + const len = buffer.length; + let pos = 0; + if (len - pos > 4) { // fast route (lo) + for (; i < 4; ++i) { + // 1st..4th + bits.lo = (bits.lo | (buffer[pos] & 127) << i * 7) >>> 0; + if (buffer[pos++] < 128) { + return bits; + } + } + // 5th + bits.lo = (bits.lo | (buffer[pos] & 127) << 28) >>> 0; + bits.hi = (bits.hi | (buffer[pos] & 127) >> 4) >>> 0; + if (buffer[pos++] < 128) { + return bits; + } + i = 0; + } else { + for (; i < 3; ++i) { + // 1st..3th + bits.lo = (bits.lo | (buffer[pos] & 127) << i * 7) >>> 0; + if (buffer[pos++] < 128) { + return bits; + } + } + // 4th + bits.lo = (bits.lo | (buffer[pos++] & 127) << i * 7) >>> 0; + return bits; + } + + // 6th..9th + for (; i < 4; ++i) { + // 最后一位直接写入 + if (pos === 8) { + bits.hi = (bits.hi | buffer[pos] << i * 7 + 3) >>> 0; + return bits; + } + bits.hi = (bits.hi | (buffer[pos] & 127) << i * 7 + 3) >>> 0; + if (buffer[pos++] < 128) { + return bits; + } + } + + return bits; +} + +function writeInt64(byteBuffer, value) { + const bits = from(value).zzEncode(); + writeVarint64(byteBuffer, bits); +} + +function readInt64(buffer) { + return readLongVarint(buffer).zzDecode().toLong(false); +} + +LongBits.writeInt64 = writeInt64; + +LongBits.readInt64 = readInt64; diff --git a/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts b/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts new file mode 100644 index 00000000..60de9fef --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/ComplexObject.ts @@ -0,0 +1,488 @@ +import ObjectA from './ObjectA'; +import ObjectB from './ObjectB'; + +// 复杂的对象 +// 包括了各种复杂的结构，数组，List，Set，Map +// +// @author jaysunxiao +// @version 3.0 +class ComplexObject { + + // byte类型，最简单的整形 + a: number = 0; + // byte的包装类型 + // 优先使用基础类型，包装类型会有装箱拆箱 + aa: number = 0; + // 数组类型 + aaa: Array | null = null; + aaaa: Array | null = null; + b: number = 0; + bb: number = 0; + bbb: Array | null = null; + bbbb: Array | null = null; + c: number = 0; + cc: number = 0; + ccc: Array | null = null; + cccc: Array | null = null; + d: number = 0; + dd: number = 0; + ddd: Array | null = null; + dddd: Array | null = null; + e: number = 0; + ee: number = 0; + eee: Array | null = null; + eeee: Array | null = null; + f: number = 0; + ff: number = 0; + fff: Array | null = null; + ffff: Array | null = null; + g: boolean = false; + gg: boolean = false; + ggg: Array | null = null; + gggg: Array | null = null; + h: string = ''; + hh: string = ''; + hhh: Array | null = null; + hhhh: Array | null = null; + jj: string = ''; + jjj: Array | null = null; + kk: ObjectA | null = null; + kkk: Array | null = null; + l: Array | null = null; + ll: Array>> | null = null; + lll: Array> | null = null; + llll: Array | null = null; + lllll: Array> | null = null; + m: Map | null = null; + mm: Map | null = null; + mmm: Map> | null = null; + mmmm: Map>, Array>>> | null = null; + mmmmm: Map>, Set>> | null = null; + s: Set | null = null; + ss: Set>> | null = null; + sss: Set> | null = null; + ssss: Set | null = null; + sssss: Set> | null = null; + // 如果要修改协议并且兼容老协议，需要加上Compatible注解，按照增加的顺序添加order + myCompatible: number = 0; + myObject: ObjectA | null = null; + + protocolId(): number { + return 100; + } + + static write(buffer: any, packet: ComplexObject | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + + buffer.writeByte(packet.a); + buffer.writeByte(packet.aa); + buffer.writeByteArray(packet.aaa); + buffer.writeByteArray(packet.aaaa); + buffer.writeShort(packet.b); + buffer.writeShort(packet.bb); + buffer.writeShortArray(packet.bbb); + buffer.writeShortArray(packet.bbbb); + buffer.writeInt(packet.c); + buffer.writeInt(packet.cc); + buffer.writeIntArray(packet.ccc); + buffer.writeIntArray(packet.cccc); + buffer.writeLong(packet.d); + buffer.writeLong(packet.dd); + buffer.writeLongArray(packet.ddd); + buffer.writeLongArray(packet.dddd); + buffer.writeFloat(packet.e); + buffer.writeFloat(packet.ee); + buffer.writeFloatArray(packet.eee); + buffer.writeFloatArray(packet.eeee); + buffer.writeDouble(packet.f); + buffer.writeDouble(packet.ff); + buffer.writeDoubleArray(packet.fff); + buffer.writeDoubleArray(packet.ffff); + buffer.writeBoolean(packet.g); + buffer.writeBoolean(packet.gg); + buffer.writeBooleanArray(packet.ggg); + buffer.writeBooleanArray(packet.gggg); + buffer.writeChar(packet.h); + buffer.writeChar(packet.hh); + buffer.writeCharArray(packet.hhh); + buffer.writeCharArray(packet.hhhh); + buffer.writeString(packet.jj); + buffer.writeStringArray(packet.jjj); + buffer.writePacket(packet.kk, 102); + buffer.writePacketArray(packet.kkk, 102); + buffer.writeIntList(packet.l); + if (packet.ll === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.ll.length); + packet.ll.forEach(element0 => { + if (element0 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(element0.length); + element0.forEach(element1 => { + buffer.writeIntList(element1); + }); + } + }); + } + if (packet.lll === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.lll.length); + packet.lll.forEach(element2 => { + buffer.writePacketList(element2, 102); + }); + } + buffer.writeStringList(packet.llll); + if (packet.lllll === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.lllll.length); + packet.lllll.forEach(element3 => { + buffer.writeIntStringMap(element3); + }); + } + buffer.writeIntStringMap(packet.m); + buffer.writeIntPacketMap(packet.mm, 102); + if (packet.mmm === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.mmm.size); + packet.mmm.forEach((value5, key4) => { + buffer.writePacket(key4, 102); + buffer.writeIntList(value5); + }); + } + if (packet.mmmm === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.mmmm.size); + packet.mmmm.forEach((value7, key6) => { + if (key6 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(key6.length); + key6.forEach(element8 => { + buffer.writePacketList(element8, 102); + }); + } + if (value7 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(value7.length); + value7.forEach(element9 => { + if (element9 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(element9.length); + element9.forEach(element10 => { + buffer.writeIntList(element10); + }); + } + }); + } + }); + } + if (packet.mmmmm === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.mmmmm.size); + packet.mmmmm.forEach((value12, key11) => { + if (key11 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(key11.length); + key11.forEach(element13 => { + buffer.writeIntStringMap(element13); + }); + } + if (value12 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(value12.size); + value12.forEach(element14 => { + buffer.writeIntStringMap(element14); + }); + } + }); + } + buffer.writeIntSet(packet.s); + if (packet.ss === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.ss.size); + packet.ss.forEach(element15 => { + if (element15 === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(element15.size); + element15.forEach(element16 => { + buffer.writeIntList(element16); + }); + } + }); + } + if (packet.sss === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.sss.size); + packet.sss.forEach(element17 => { + buffer.writePacketSet(element17, 102); + }); + } + buffer.writeStringSet(packet.ssss); + if (packet.sssss === null) { + buffer.writeInt(0); + } else { + buffer.writeInt(packet.sssss.size); + packet.sssss.forEach(element18 => { + buffer.writeIntStringMap(element18); + }); + } + buffer.writeInt(packet.myCompatible); + buffer.writePacket(packet.myObject, 102); + } + + static read(buffer: any): ComplexObject | null { + if (!buffer.readBoolean()) { + return null; + } + const packet = new ComplexObject(); + const result19 = buffer.readByte(); + packet.a = result19; + const result20 = buffer.readByte(); + packet.aa = result20; + const array21 = buffer.readByteArray(); + packet.aaa = array21; + const array22 = buffer.readByteArray(); + packet.aaaa = array22; + const result23 = buffer.readShort(); + packet.b = result23; + const result24 = buffer.readShort(); + packet.bb = result24; + const array25 = buffer.readShortArray(); + packet.bbb = array25; + const array26 = buffer.readShortArray(); + packet.bbbb = array26; + const result27 = buffer.readInt(); + packet.c = result27; + const result28 = buffer.readInt(); + packet.cc = result28; + const array29 = buffer.readIntArray(); + packet.ccc = array29; + const array30 = buffer.readIntArray(); + packet.cccc = array30; + const result31 = buffer.readLong(); + packet.d = result31; + const result32 = buffer.readLong(); + packet.dd = result32; + const array33 = buffer.readLongArray(); + packet.ddd = array33; + const array34 = buffer.readLongArray(); + packet.dddd = array34; + const result35 = buffer.readFloat(); + packet.e = result35; + const result36 = buffer.readFloat(); + packet.ee = result36; + const array37 = buffer.readFloatArray(); + packet.eee = array37; + const array38 = buffer.readFloatArray(); + packet.eeee = array38; + const result39 = buffer.readDouble(); + packet.f = result39; + const result40 = buffer.readDouble(); + packet.ff = result40; + const array41 = buffer.readDoubleArray(); + packet.fff = array41; + const array42 = buffer.readDoubleArray(); + packet.ffff = array42; + const result43 = buffer.readBoolean(); + packet.g = result43; + const result44 = buffer.readBoolean(); + packet.gg = result44; + const array45 = buffer.readBooleanArray(); + packet.ggg = array45; + const array46 = buffer.readBooleanArray(); + packet.gggg = array46; + const result47 = buffer.readChar(); + packet.h = result47; + const result48 = buffer.readChar(); + packet.hh = result48; + const array49 = buffer.readCharArray(); + packet.hhh = array49; + const array50 = buffer.readCharArray(); + packet.hhhh = array50; + const result51 = buffer.readString(); + packet.jj = result51; + const array52 = buffer.readStringArray(); + packet.jjj = array52; + const result53 = buffer.readPacket(102); + packet.kk = result53; + const array54 = buffer.readPacketArray(102); + packet.kkk = array54; + const list55 = buffer.readIntList(); + packet.l = list55; + const result56 = new Array>>(); + const size57 = buffer.readInt(); + if (size57 > 0) { + for (let index58 = 0; index58 < size57; index58++) { + const result59 = new Array>(); + const size60 = buffer.readInt(); + if (size60 > 0) { + for (let index61 = 0; index61 < size60; index61++) { + const list62 = buffer.readIntList(); + result59.push(list62); + } + } + result56.push(result59); + } + } + packet.ll = result56; + const result63 = new Array>(); + const size64 = buffer.readInt(); + if (size64 > 0) { + for (let index65 = 0; index65 < size64; index65++) { + const list66 = buffer.readPacketList(102); + result63.push(list66); + } + } + packet.lll = result63; + const list67 = buffer.readStringList(); + packet.llll = list67; + const result68 = new Array>(); + const size69 = buffer.readInt(); + if (size69 > 0) { + for (let index70 = 0; index70 < size69; index70++) { + const map71 = buffer.readIntStringMap(); + result68.push(map71); + } + } + packet.lllll = result68; + const map72 = buffer.readIntStringMap(); + packet.m = map72; + const map73 = buffer.readIntPacketMap(102); + packet.mm = map73; + const result74 = new Map>(); + const size75 = buffer.readInt(); + if (size75 > 0) { + for (let index76 = 0; index76 < size75; index76++) { + const result77 = buffer.readPacket(102); + const list78 = buffer.readIntList(); + result74.set(result77, list78); + } + } + packet.mmm = result74; + const result79 = new Map>, Array>>>(); + const size80 = buffer.readInt(); + if (size80 > 0) { + for (let index81 = 0; index81 < size80; index81++) { + const result82 = new Array>(); + const size83 = buffer.readInt(); + if (size83 > 0) { + for (let index84 = 0; index84 < size83; index84++) { + const list85 = buffer.readPacketList(102); + result82.push(list85); + } + } + const result86 = new Array>>(); + const size87 = buffer.readInt(); + if (size87 > 0) { + for (let index88 = 0; index88 < size87; index88++) { + const result89 = new Array>(); + const size90 = buffer.readInt(); + if (size90 > 0) { + for (let index91 = 0; index91 < size90; index91++) { + const list92 = buffer.readIntList(); + result89.push(list92); + } + } + result86.push(result89); + } + } + result79.set(result82, result86); + } + } + packet.mmmm = result79; + const result93 = new Map>, Set>>(); + const size94 = buffer.readInt(); + if (size94 > 0) { + for (let index95 = 0; index95 < size94; index95++) { + const result96 = new Array>(); + const size97 = buffer.readInt(); + if (size97 > 0) { + for (let index98 = 0; index98 < size97; index98++) { + const map99 = buffer.readIntStringMap(); + result96.push(map99); + } + } + const result100 = new Set>(); + const size101 = buffer.readInt(); + if (size101 > 0) { + for (let index102 = 0; index102 < size101; index102++) { + const map103 = buffer.readIntStringMap(); + result100.add(map103); + } + } + result93.set(result96, result100); + } + } + packet.mmmmm = result93; + const set104 = buffer.readIntSet(); + packet.s = set104; + const result105 = new Set>>(); + const size106 = buffer.readInt(); + if (size106 > 0) { + for (let index107 = 0; index107 < size106; index107++) { + const result108 = new Set>(); + const size109 = buffer.readInt(); + if (size109 > 0) { + for (let index110 = 0; index110 < size109; index110++) { + const list111 = buffer.readIntList(); + result108.add(list111); + } + } + result105.add(result108); + } + } + packet.ss = result105; + const result112 = new Set>(); + const size113 = buffer.readInt(); + if (size113 > 0) { + for (let index114 = 0; index114 < size113; index114++) { + const set115 = buffer.readPacketSet(102); + result112.add(set115); + } + } + packet.sss = result112; + const set116 = buffer.readStringSet(); + packet.ssss = set116; + const result117 = new Set>(); + const size118 = buffer.readInt(); + if (size118 > 0) { + for (let index119 = 0; index119 < size118; index119++) { + const map120 = buffer.readIntStringMap(); + result117.add(map120); + } + } + packet.sssss = result117; + if (!buffer.isReadable()) { + return packet; + } + const result121 = buffer.readInt(); + packet.myCompatible = result121; + if (!buffer.isReadable()) { + return packet; + } + const result122 = buffer.readPacket(102); + packet.myObject = result122; + return packet; + } +} + +export default ComplexObject; diff --git a/protocol/src/test/typescript/zfoo/packet/NormalObject.ts b/protocol/src/test/typescript/zfoo/packet/NormalObject.ts new file mode 100644 index 00000000..c3c95aaf --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/NormalObject.ts @@ -0,0 +1,104 @@ +import ObjectA from './ObjectA'; +import ObjectB from './ObjectB'; + +// @author jaysunxiao +// @version 3.0 +class NormalObject { + + a: number = 0; + aaa: Array | null = null; + b: number = 0; + c: number = 0; + d: number = 0; + e: number = 0; + f: number = 0; + g: boolean = false; + jj: string = ''; + kk: ObjectA | null = null; + l: Array | null = null; + ll: Array | null = null; + lll: Array | null = null; + llll: Array | null = null; + m: Map | null = null; + mm: Map | null = null; + s: Set | null = null; + ssss: Set | null = null; + + protocolId(): number { + return 101; + } + + static write(buffer: any, packet: NormalObject | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + + buffer.writeByte(packet.a); + buffer.writeByteArray(packet.aaa); + buffer.writeShort(packet.b); + buffer.writeInt(packet.c); + buffer.writeLong(packet.d); + buffer.writeFloat(packet.e); + buffer.writeDouble(packet.f); + buffer.writeBoolean(packet.g); + buffer.writeString(packet.jj); + buffer.writePacket(packet.kk, 102); + buffer.writeIntList(packet.l); + buffer.writeLongList(packet.ll); + buffer.writePacketList(packet.lll, 102); + buffer.writeStringList(packet.llll); + buffer.writeIntStringMap(packet.m); + buffer.writeIntPacketMap(packet.mm, 102); + buffer.writeIntSet(packet.s); + buffer.writeStringSet(packet.ssss); + } + + static read(buffer: any): NormalObject | null { + if (!buffer.readBoolean()) { + return null; + } + const packet = new NormalObject(); + const result0 = buffer.readByte(); + packet.a = result0; + const array1 = buffer.readByteArray(); + packet.aaa = array1; + const result2 = buffer.readShort(); + packet.b = result2; + const result3 = buffer.readInt(); + packet.c = result3; + const result4 = buffer.readLong(); + packet.d = result4; + const result5 = buffer.readFloat(); + packet.e = result5; + const result6 = buffer.readDouble(); + packet.f = result6; + const result7 = buffer.readBoolean(); + packet.g = result7; + const result8 = buffer.readString(); + packet.jj = result8; + const result9 = buffer.readPacket(102); + packet.kk = result9; + const list10 = buffer.readIntList(); + packet.l = list10; + const list11 = buffer.readLongList(); + packet.ll = list11; + const list12 = buffer.readPacketList(102); + packet.lll = list12; + const list13 = buffer.readStringList(); + packet.llll = list13; + const map14 = buffer.readIntStringMap(); + packet.m = map14; + const map15 = buffer.readIntPacketMap(102); + packet.mm = map15; + const set16 = buffer.readIntSet(); + packet.s = set16; + const set17 = buffer.readStringSet(); + packet.ssss = set17; + return packet; + } +} + +export default NormalObject; diff --git a/protocol/src/test/typescript/zfoo/packet/ObjectA.ts b/protocol/src/test/typescript/zfoo/packet/ObjectA.ts new file mode 100644 index 00000000..c2753fe3 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/ObjectA.ts @@ -0,0 +1,43 @@ +import ObjectB from './ObjectB'; + +// @author jaysunxiao +// @version 3.0 +class ObjectA { + + a: number = 0; + m: Map | null = null; + objectB: ObjectB | null = null; + + protocolId(): number { + return 102; + } + + static write(buffer: any, packet: ObjectA | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + + buffer.writeInt(packet.a); + buffer.writeIntStringMap(packet.m); + buffer.writePacket(packet.objectB, 103); + } + + static read(buffer: any): ObjectA | null { + if (!buffer.readBoolean()) { + return null; + } + const packet = new ObjectA(); + const result0 = buffer.readInt(); + packet.a = result0; + const map1 = buffer.readIntStringMap(); + packet.m = map1; + const result2 = buffer.readPacket(103); + packet.objectB = result2; + return packet; + } +} + +export default ObjectA; diff --git a/protocol/src/test/typescript/zfoo/packet/ObjectB.ts b/protocol/src/test/typescript/zfoo/packet/ObjectB.ts new file mode 100644 index 00000000..87e9e1a0 --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/ObjectB.ts @@ -0,0 +1,34 @@ + +// @author jaysunxiao +// @version 3.0 +class ObjectB { + + flag: boolean = false; + + protocolId(): number { + return 103; + } + + static write(buffer: any, packet: ObjectB | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + + buffer.writeBoolean(packet.flag); + } + + static read(buffer: any): ObjectB | null { + if (!buffer.readBoolean()) { + return null; + } + const packet = new ObjectB(); + const result0 = buffer.readBoolean(); + packet.flag = result0; + return packet; + } +} + +export default ObjectB; diff --git a/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts b/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts new file mode 100644 index 00000000..303ce65d --- /dev/null +++ b/protocol/src/test/typescript/zfoo/packet/SimpleObject.ts @@ -0,0 +1,38 @@ + +// @author jaysunxiao +// @version 3.0 +class SimpleObject { + + c: number = 0; + g: boolean = false; + + protocolId(): number { + return 104; + } + + static write(buffer: any, packet: SimpleObject | null) { + if (buffer.writePacketFlag(packet)) { + return; + } + if (packet === null) { + return; + } + + buffer.writeInt(packet.c); + buffer.writeBoolean(packet.g); + } + + static read(buffer: any): SimpleObject | null { + if (!buffer.readBoolean()) { + return null; + } + const packet = new SimpleObject(); + const result0 = buffer.readInt(); + packet.c = result0; + const result1 = buffer.readBoolean(); + packet.g = result1; + return packet; + } +} + +export default SimpleObject;