From 428652b433a25d20a6cb455169736c5c1d2d091e Mon Sep 17 00:00:00 2001 From: walon Date: Sat, 1 May 2021 14:49:22 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E7=89=B9=E6=80=A7=E3=80=91=E3=80=90cf?= =?UTF-8?q?g=E3=80=91=20=E6=96=B0=E5=A2=9Epuerts=20+=20unity=E6=A1=86?= =?UTF-8?q?=E6=9E=B6=E4=B8=8B=E5=8A=A0=E8=BD=BDbin=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E6=95=B0=E6=8D=AE=E7=9A=84Typescript=20=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E7=94=9F=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/Defines/{root.xml => __root__.xml} | 0 config/Defines/test.xml | 2 +- src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs | 2 +- src/Luban.Job.Cfg/Source/Defs/DefField.cs | 2 +- .../Source/Defs/TTypeTemplateExtends.cs | 9 +- .../Generate/TypeScriptBinCodeRender.cs | 234 ++++++++++++++++++ .../Generate/TypeScriptJsonCodeRender.cs | 50 +--- .../Generate/TypescriptCodeRenderBase.cs | 59 +++++ src/Luban.Job.Cfg/Source/JobController.cs | 119 ++++++++- .../TypescriptDeserializeBinVisitor.cs | 27 ++ ...tor.cs => TypescriptDeserializeVisitor.cs} | 10 +- ...s => TypescriptRecursiveResolveVisitor.cs} | 4 +- ...TypescriptUnderingDeserializeBinVisitor.cs | 167 +++++++++++++ ...> TypescriptUnderingDeserializeVisitor.cs} | 20 +- .../Source/Defs/TTypeTemplateCommonExtends.cs | 2 +- ...ypeName.cs => TypescriptDefineTypeName.cs} | 10 +- 16 files changed, 638 insertions(+), 79 deletions(-) rename config/Defines/{root.xml => __root__.xml} (100%) create mode 100644 src/Luban.Job.Cfg/Source/Generate/TypeScriptBinCodeRender.cs create mode 100644 src/Luban.Job.Cfg/Source/Generate/TypescriptCodeRenderBase.cs create mode 100644 src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeBinVisitor.cs rename src/Luban.Job.Cfg/Source/TypeVisitors/{TsDeserializeVisitor.cs => TypescriptDeserializeVisitor.cs} (50%) rename src/Luban.Job.Cfg/Source/TypeVisitors/{TsRecursiveResolveVisitor.cs => TypescriptRecursiveResolveVisitor.cs} (94%) create mode 100644 src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeBinVisitor.cs rename src/Luban.Job.Cfg/Source/TypeVisitors/{TsUnderingDeserializeVisitor.cs => TypescriptUnderingDeserializeVisitor.cs} (74%) rename src/Luban.Job.Common/Source/TypeVisitors/{TsDefineTypeName.cs => TypescriptDefineTypeName.cs} (91%) diff --git a/config/Defines/root.xml b/config/Defines/__root__.xml similarity index 100% rename from config/Defines/root.xml rename to config/Defines/__root__.xml diff --git a/config/Defines/test.xml b/config/Defines/test.xml index 08bcb66..62edbee 100644 --- a/config/Defines/test.xml +++ b/config/Defines/test.xml @@ -37,7 +37,7 @@ - + diff --git a/src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs b/src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs index 37b40d9..f8f2f61 100644 --- a/src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs +++ b/src/Luban.Job.Cfg/Source/Defs/CfgDefLoader.cs @@ -239,7 +239,7 @@ namespace Luban.Job.Cfg.Defs if (!_name2CfgTable.TryAdd(p.Name, p)) { var exist = _name2CfgTable[p.Name]; - throw new Exception($"定义文件:{CurImportFile} table:{p.Namespace}.{p.Name} 与 {exist.Namespace}.{exist.Name} 重复"); + throw new Exception($"定义文件:{CurImportFile} table:{p.Namespace}.{p.Name} 与 {exist.Namespace}.{exist.Name} 名称不能重复"); } _cfgTables.Add(p); } diff --git a/src/Luban.Job.Cfg/Source/Defs/DefField.cs b/src/Luban.Job.Cfg/Source/Defs/DefField.cs index e0a1589..6c3165a 100644 --- a/src/Luban.Job.Cfg/Source/Defs/DefField.cs +++ b/src/Luban.Job.Cfg/Source/Defs/DefField.cs @@ -94,7 +94,7 @@ namespace Luban.Job.Cfg.Defs get { var table = Assembly.GetCfgTable(Ref.FirstTable); - return $"{TsRefVarName} : {table.ValueTType.Apply(TsDefineTypeName.Ins)};"; + return $"{TsRefVarName} : {table.ValueTType.Apply(TypescriptDefineTypeName.Ins)};"; } } diff --git a/src/Luban.Job.Cfg/Source/Defs/TTypeTemplateExtends.cs b/src/Luban.Job.Cfg/Source/Defs/TTypeTemplateExtends.cs index b713190..761a30b 100644 --- a/src/Luban.Job.Cfg/Source/Defs/TTypeTemplateExtends.cs +++ b/src/Luban.Job.Cfg/Source/Defs/TTypeTemplateExtends.cs @@ -100,12 +100,12 @@ namespace Luban.Job.Cfg.Defs public static string TsDeserialize(string fieldName, string jsonFieldName, TType type) { - return type.Apply(TsDeserializeVisitor.Ins, $"{jsonFieldName}", fieldName); + return type.Apply(TypescriptDeserializeVisitor.Ins, $"{jsonFieldName}", fieldName); } public static string TsRecursiveResolve(DefField field, string tables) { - return field.CType.Apply(TsRecursiveResolveVisitor.Ins, "this." + field.CsStyleName, tables); + return field.CType.Apply(TypescriptRecursiveResolveVisitor.Ins, "this." + field.CsStyleName, tables); } public static string TsRefValidatorResolve(DefField field) @@ -124,6 +124,11 @@ namespace Luban.Job.Cfg.Defs } } + public static string TsDeserializeBin(string fieldName, string byteBufName, TType type) + { + return type.Apply(TypescriptDeserializeBinVisitor.Ins, byteBufName, fieldName); + } + public static string Py3Deserialize(string fieldName, string jsonFieldName, TType type) { return type.Apply(PyDeserializeVisitor.Py3Ins, $"{jsonFieldName}", fieldName); diff --git a/src/Luban.Job.Cfg/Source/Generate/TypeScriptBinCodeRender.cs b/src/Luban.Job.Cfg/Source/Generate/TypeScriptBinCodeRender.cs new file mode 100644 index 0000000..6b664b2 --- /dev/null +++ b/src/Luban.Job.Cfg/Source/Generate/TypeScriptBinCodeRender.cs @@ -0,0 +1,234 @@ +using Luban.Job.Cfg.Defs; +using Luban.Job.Common.Defs; +using Scriban; +using System; +using System.Collections.Generic; + +namespace Luban.Job.Cfg.Generate +{ + class TypeScriptBinCodeRender : TypescriptCodeRenderBase + { + + + [ThreadStatic] + private static Template t_beanRender; + public override string Render(DefBean b) + { + var template = t_beanRender ??= Template.Parse(@" + +{{ + name = x.name + parent_def_type = x.parent_def_type + export_fields = x.export_fields + hierarchy_export_fields = x.hierarchy_export_fields +}} + +namespace {{x.namespace}} { + +export {{if x.is_abstract_type}} abstract {{end}} class {{name}} {{if parent_def_type}} extends {{x.parent}}{{end}} { +{{~if x.is_abstract_type~}} + static deserialize(_buf_ : Bright.Serialization.ByteBuf) : {{name}} { + switch (_buf_.ReadInt()) + { + case 0 : return null; + {{~ for child in x.hierarchy_not_abstract_children~}} + case {{child.id}}: return new {{child.full_name}}(_buf_); + {{~end~}} + default: throw new Error(); + } + } +{{~end~}} + + constructor(_buf_ : Bright.Serialization.ByteBuf) { + {{~if parent_def_type~}} + super(_buf_); + {{~end~}} + {{~ for field in export_fields ~}} + {{ts_deserialize_bin ('this.' + field.ts_style_name) '_buf_' field.ctype}} + {{~end~}} + } + + {{~ for field in export_fields ~}} + {{field.ts_style_name}}{{if field.is_nullable}}?{{end}} : {{ts_define_type field.ctype}}; + {{~if field.gen_ref~}} + {{field.ts_ref_validator_define}} + {{~end~}} + {{~end~}} + + resolve(_tables : Map) : void { + {{~if parent_def_type~}} + super.resolve(_tables); + {{~end~}} + {{~ for field in export_fields ~}} + {{~if field.gen_ref~}} + {{ts_ref_validator_resolve field}} + {{~else if field.has_recursive_ref~}} + {{ts_recursive_resolve field '_tables'}} + {{~end~}} + {{~end~}} + } +} + +} +"); + var result = template.RenderCode(b); + + return result; + } + + [ThreadStatic] + private static Template t_tableRender; + public override string Render(DefTable p) + { + var template = t_tableRender ??= Template.Parse(@" + {{ + name = x.name + key_type = x.key_ttype + key_type1 = x.key_ttype1 + key_type2 = x.key_ttype2 + value_type = x.value_ttype + }} +namespace {{x.namespace}} { +export class {{name}}{ + {{~ if x.is_two_key_map_table ~}} + private _dataListMap : Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>; + private _dataMapMap : Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>; + private _dataList : {{ts_define_type value_type}}[]; + + constructor(_buf_ : Bright.Serialization.ByteBuf) { + this._dataListMap = new Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]>(); + this._dataMapMap = new Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>>(); + this._dataList = []; + + for(let n = _buf_.ReadInt(); n > 0 ; n--) { + let _v : {{ts_define_type value_type}}; + {{ts_deserialize_bin '_v' '_buf_' value_type}} + this._dataList.push(_v); + var _key = _v.{{x.index_field1.ts_style_name}}; + let list : {{ts_define_type value_type}}[] = this._dataListMap.get(_key); + if (list == null) { + list = []; + this._dataListMap.set(_key, list); + } + list.push(_v); + + let map : Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}> = this._dataMapMap.get(_key); + if (map == null) { + map = new Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>(); + this._dataMapMap.set(_key, map); + } + map.set(_v.{{x.index_field2.ts_style_name}}, _v); + } + } + + getDataListMap() : Map<{{ts_define_type key_type1}}, {{ts_define_type value_type}}[]> { return this._dataListMap; } + getDataMapMap() : Map<{{ts_define_type key_type1}}, Map<{{ts_define_type key_type2}}, {{ts_define_type value_type}}>> { return this._dataMapMap; } + getDataList() : {{ts_define_type value_type}}[] { return this._dataList; } + + get(key1 : {{ts_define_type key_type1}}, key2 : {{ts_define_type key_type2}}) : {{ts_define_type value_type}} { return this._dataMapMap.get(key1).get(key2); } + + resolve(_tables : Map) : void { + for(var v of this._dataList) { + v.resolve(_tables); + } + } + {{~else if x.is_map_table ~}} + private _dataMap : Map<{{ts_define_type key_type}}, {{ts_define_type value_type}}>; + private _dataList : {{ts_define_type value_type}}[]; + + constructor(_buf_ : Bright.Serialization.ByteBuf) { + this._dataMap = new Map<{{ts_define_type key_type}}, {{ts_define_type value_type}}>(); + this._dataList = []; + + for(let n = _buf_.ReadInt() ; n > 0 ; n--) { + let _v : {{ts_define_type value_type}}; + {{ts_deserialize_bin '_v' '_buf_' value_type}} + this._dataList.push(_v); + this._dataMap.set(_v.{{x.index_field.ts_style_name}}, _v); + } + } + + getDataMap() : Map<{{ts_define_type key_type}}, {{ts_define_type value_type}}> { return this._dataMap; } + getDataList() : {{ts_define_type value_type}}[] { return this._dataList; } + + get(key : {{ts_define_type key_type}}) : {{ts_define_type value_type}} { return this._dataMap.get(key); } + + resolve(_tables : Map) : void { + for(var v of this._dataList) { + v.resolve(_tables); + } + } + + {{~else~}} + + private _data : {{ts_define_type value_type}}; + + constructor(_buf_ : Bright.Serialization.ByteBuf) { + if (_buf_.ReadInt() != 1) throw new Error('table mode=one, but size != 1'); + {{ts_deserialize_bin 'this._data' '_buf_' value_type}} + } + + getData() : {{ts_define_type value_type}} { return this._data; } + + {{~ for field in value_type.bean.hierarchy_export_fields ~}} + get {{field.ts_style_name}}() : {{ts_define_type field.ctype}} { return this._data.{{field.ts_style_name}}; } + {{~end~}} + + resolve(_tables : Map) : void { + this._data.resolve(_tables); + } + + {{end}} +} +} +"); + var result = template.RenderCode(p); + + return result; + } + + [ThreadStatic] + private static Template t_serviceRender; + public override string RenderService(string name, string module, List tables) + { + var template = t_serviceRender ??= Template.Parse(@" +{{ + name = x.name + namespace = x.namespace + tables = x.tables + +}} + +type ByteBufLoader = (file : string) => Bright.Serialization.ByteBuf + +export class {{name}} { + {{~ for table in tables ~}} + private _{{table.name}} : {{table.full_name}}; + get {{table.name}}() : {{table.full_name}} { return this._{{table.name}};} + {{~end~}} + + constructor(loader : ByteBufLoader) { + let tables = new Map(); + {{~for table in tables ~}} + this._{{table.name}} = new {{table.full_name}}(loader('{{table.output_data_file}}')); + tables.set('{{table.full_name}}', this._{{table.name}}); + {{~end~}} + + {{~ for table in tables ~}} + this._{{table.name}}.resolve(tables); + {{~end~}} + } +} + +"); + var result = template.RenderCode(new + { + Name = name, + Namespace = module, + Tables = tables, + }); + + return result; + } + } +} diff --git a/src/Luban.Job.Cfg/Source/Generate/TypeScriptJsonCodeRender.cs b/src/Luban.Job.Cfg/Source/Generate/TypeScriptJsonCodeRender.cs index a7143f4..8e50379 100644 --- a/src/Luban.Job.Cfg/Source/Generate/TypeScriptJsonCodeRender.cs +++ b/src/Luban.Job.Cfg/Source/Generate/TypeScriptJsonCodeRender.cs @@ -6,54 +6,8 @@ using System.Collections.Generic; namespace Luban.Job.Cfg.Generate { - class TypeScriptJsonCodeRender : CodeRenderBase + class TypeScriptJsonCodeRender : TypescriptCodeRenderBase { - [ThreadStatic] - private static Template t_tsConstRender; - public override string Render(DefConst c) - { - var ctx = new TemplateContext(); - var env = new TTypeTemplateCommonExtends - { - ["x"] = c - }; - ctx.PushGlobal(env); - - - var template = t_tsConstRender ??= Template.Parse(@" -namespace {{x.namespace}} { -export class {{x.name}} { - {{~ for item in x.items ~}} - static {{item.name}} : {{ts_define_type item.ctype}} = {{ts_const_value item.ctype item.value}}; - {{~end~}} -} -} - -"); - var result = template.Render(ctx); - - return result; - } - - [ThreadStatic] - private static Template t_tsEnumRender; - public override string Render(DefEnum e) - { - var template = t_tsEnumRender ??= Template.Parse(@" -namespace {{namespace}} { -export enum {{name}} { - {{- for item in items }} - {{item.name}} = {{item.value}}, - {{-end}} -} -} - -"); - var result = template.Render(e); - - return result; - } - [ThreadStatic] private static Template t_beanRender; public override string Render(DefBean b) @@ -96,7 +50,7 @@ export {{if x.is_abstract_type}} abstract {{end}} class {{name}} {{if parent_def } {{~ for field in export_fields ~}} - {{field.ts_style_name}} : {{ts_define_type field.ctype}}; + {{field.ts_style_name}}{{if field.is_nullable}}?{{end}} : {{ts_define_type field.ctype}}; {{~if field.gen_ref~}} {{field.ts_ref_validator_define}} {{~end~}} diff --git a/src/Luban.Job.Cfg/Source/Generate/TypescriptCodeRenderBase.cs b/src/Luban.Job.Cfg/Source/Generate/TypescriptCodeRenderBase.cs new file mode 100644 index 0000000..d1b0282 --- /dev/null +++ b/src/Luban.Job.Cfg/Source/Generate/TypescriptCodeRenderBase.cs @@ -0,0 +1,59 @@ +using Luban.Job.Common.Defs; +using Scriban; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Luban.Job.Cfg.Generate +{ + abstract class TypescriptCodeRenderBase : CodeRenderBase + { + [ThreadStatic] + private static Template t_tsConstRender; + public override string Render(DefConst c) + { + var ctx = new TemplateContext(); + var env = new TTypeTemplateCommonExtends + { + ["x"] = c + }; + ctx.PushGlobal(env); + + + var template = t_tsConstRender ??= Template.Parse(@" +namespace {{x.namespace}} { +export class {{x.name}} { + {{~ for item in x.items ~}} + static {{item.name}} = {{ts_const_value item.ctype item.value}}; + {{~end~}} +} +} + +"); + var result = template.Render(ctx); + + return result; + } + + [ThreadStatic] + private static Template t_tsEnumRender; + public override string Render(DefEnum e) + { + var template = t_tsEnumRender ??= Template.Parse(@" +namespace {{namespace}} { +export enum {{name}} { + {{- for item in items }} + {{item.name}} = {{item.value}}, + {{-end}} +} +} + +"); + var result = template.Render(e); + + return result; + } + } +} diff --git a/src/Luban.Job.Cfg/Source/JobController.cs b/src/Luban.Job.Cfg/Source/JobController.cs index 8ed4225..edce4b6 100644 --- a/src/Luban.Job.Cfg/Source/JobController.cs +++ b/src/Luban.Job.Cfg/Source/JobController.cs @@ -435,7 +435,7 @@ export class Vector2 { this.y = y; } - static fromJson(_json_: any): Vector2 { + static from(_json_: any): Vector2 { let x = _json_['x']; let y = _json_['y']; if (x == null || y == null) { @@ -456,7 +456,7 @@ export class Vector2 { this.z = z; } - static fromJson(_json_: any): Vector3 { + static from(_json_: any): Vector3 { let x = _json_['x']; let y = _json_['y']; let z = _json_['z']; @@ -479,7 +479,7 @@ export class Vector2 { this.w = w; } - static fromJson(_json_: any): Vector4 { + static from(_json_: any): Vector4 { let x = _json_['x']; let y = _json_['y']; let z = _json_['z']; @@ -491,6 +491,119 @@ export class Vector2 { } } +" + }; + + foreach (var type in exportTypes) + { + if (type is DefEnum e) + { + fileContent.Add(render.Render(e)); + } + } + + foreach (var type in exportTypes) + { + if (type is DefConst c) + { + fileContent.Add(render.Render(c)); + } + } + + foreach (var type in exportTypes) + { + if (type is DefBean e) + { + fileContent.Add(render.Render(e)); + } + } + + foreach (var type in exportTables) + { + fileContent.Add(render.Render(type)); + } + + fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables)); + + fileContent.Add("}"); // end of topmodule + + var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.TYPESCRIPT); + var file = "Types.ts"; + var md5 = CacheFileUtil.GenMd5AndAddCache(file, content); + genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 }); + })); + break; + } + + case "code_typescript_bin": + { + var render = new TypeScriptBinCodeRender(); + tasks.Add(Task.Run(() => + { + var fileContent = new List + { + @$" +import {{Bright}} from 'csharp' + +export namespace {ass.TopModule} {{ +", + + @" +export class Vector2 { + x: number; + y: number; + constructor(x: number, y: number) { + this.x = x; + this.y = y; + } + + static from(_buf_: Bright.Serialization.ByteBuf): Vector2 { + let x = _buf_.ReadFloat(); + let y = _buf_.ReadFloat(); + return new Vector2(x, y); + } + } + + + export class Vector3 { + x: number; + y: number; + z: number; + constructor(x: number, y: number, z: number) { + this.x = x; + this.y = y; + this.z = z; + } + + static from(_buf_: Bright.Serialization.ByteBuf): Vector3 { + let x = _buf_.ReadFloat(); + let y = _buf_.ReadFloat(); + let z = _buf_.ReadFloat(); + return new Vector3(x, y, z); + } + } + + export class Vector4 { + x: number; + y: number; + z: number; + w: number; + constructor(x: number, y: number, z: number, w: number) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + static from(_buf_: Bright.Serialization.ByteBuf): Vector4 { + let x = _buf_.ReadFloat(); + let y = _buf_.ReadFloat(); + let z = _buf_.ReadFloat(); + let w = _buf_.ReadFloat(); + return new Vector4(x, y, z, w); + } + } + " }; diff --git a/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeBinVisitor.cs b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeBinVisitor.cs new file mode 100644 index 0000000..be415b3 --- /dev/null +++ b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeBinVisitor.cs @@ -0,0 +1,27 @@ +using Luban.Job.Common.Types; +using Luban.Job.Common.TypeVisitors; + +namespace Luban.Job.Cfg.TypeVisitors +{ + class TypescriptDeserializeBinVisitor : DecoratorFuncVisitor + { + public static TypescriptDeserializeBinVisitor Ins { get; } = new TypescriptDeserializeBinVisitor(); + + public override string DoAccept(TType type, string byteBufName, string fieldName) + { + if (type.IsNullable) + { + return $"if({byteBufName}.ReadBool()) {{ {type.Apply(TypescriptUnderingDeserializeBinVisitor.Ins, byteBufName, fieldName)} }} else {{ {fieldName} = null; }}"; + } + else + { + return type.Apply(TypescriptUnderingDeserializeBinVisitor.Ins, byteBufName, fieldName); + } + } + + public override string Accept(TBean type, string bufName, string fieldName) + { + return type.Apply(TypescriptUnderingDeserializeBinVisitor.Ins, bufName, fieldName); + } + } +} diff --git a/src/Luban.Job.Cfg/Source/TypeVisitors/TsDeserializeVisitor.cs b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeVisitor.cs similarity index 50% rename from src/Luban.Job.Cfg/Source/TypeVisitors/TsDeserializeVisitor.cs rename to src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeVisitor.cs index 08f0427..9f17ef8 100644 --- a/src/Luban.Job.Cfg/Source/TypeVisitors/TsDeserializeVisitor.cs +++ b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptDeserializeVisitor.cs @@ -3,25 +3,25 @@ using Luban.Job.Common.TypeVisitors; namespace Luban.Job.Cfg.TypeVisitors { - class TsDeserializeVisitor : DecoratorFuncVisitor + class TypescriptDeserializeVisitor : DecoratorFuncVisitor { - public static TsDeserializeVisitor Ins { get; } = new TsDeserializeVisitor(); + public static TypescriptDeserializeVisitor Ins { get; } = new TypescriptDeserializeVisitor(); public override string DoAccept(TType type, string jsonFieldName, string fieldName) { if (type.IsNullable) { - return $"if({jsonFieldName} != null) {{ {type.Apply(TsUnderingDeserializeVisitor.Ins, jsonFieldName, fieldName)} }} else {{ {fieldName} = null; }}"; + return $"if({jsonFieldName} != null) {{ {type.Apply(TypescriptUnderingDeserializeVisitor.Ins, jsonFieldName, fieldName)} }} else {{ {fieldName} = null; }}"; } else { - return type.Apply(TsUnderingDeserializeVisitor.Ins, jsonFieldName, fieldName); + return type.Apply(TypescriptUnderingDeserializeVisitor.Ins, jsonFieldName, fieldName); } } public override string Accept(TBean type, string bufName, string fieldName) { - return type.Apply(TsUnderingDeserializeVisitor.Ins, bufName, fieldName); + return type.Apply(TypescriptUnderingDeserializeVisitor.Ins, bufName, fieldName); } } } diff --git a/src/Luban.Job.Cfg/Source/TypeVisitors/TsRecursiveResolveVisitor.cs b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptRecursiveResolveVisitor.cs similarity index 94% rename from src/Luban.Job.Cfg/Source/TypeVisitors/TsRecursiveResolveVisitor.cs rename to src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptRecursiveResolveVisitor.cs index c41f0e6..d834656 100644 --- a/src/Luban.Job.Cfg/Source/TypeVisitors/TsRecursiveResolveVisitor.cs +++ b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptRecursiveResolveVisitor.cs @@ -4,9 +4,9 @@ using System; namespace Luban.Job.Cfg.TypeVisitors { - class TsRecursiveResolveVisitor : ITypeFuncVisitor + class TypescriptRecursiveResolveVisitor : ITypeFuncVisitor { - public static TsRecursiveResolveVisitor Ins { get; } = new TsRecursiveResolveVisitor(); + public static TypescriptRecursiveResolveVisitor Ins { get; } = new TypescriptRecursiveResolveVisitor(); public string Accept(TBool type, string fieldName, string tablesName) { diff --git a/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeBinVisitor.cs b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeBinVisitor.cs new file mode 100644 index 0000000..3a2de4b --- /dev/null +++ b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeBinVisitor.cs @@ -0,0 +1,167 @@ +using Luban.Job.Common.Types; +using Luban.Job.Common.TypeVisitors; + +namespace Luban.Job.Cfg.TypeVisitors +{ + class TypescriptUnderingDeserializeBinVisitor : ITypeFuncVisitor + { + public static TypescriptUnderingDeserializeBinVisitor Ins { get; } = new TypescriptUnderingDeserializeBinVisitor(); + + public string Accept(TBool type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadBool();"; + } + + public string Accept(TByte type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadByte();"; + } + + public string Accept(TShort type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadShort();"; + } + + public string Accept(TFshort type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadFshort();"; + } + + public string Accept(TInt type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadInt();"; + } + + public string Accept(TFint type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadFint();"; + } + + public string Accept(TLong type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadLong();"; + } + + public string Accept(TFlong type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadFlong();"; + } + + public string Accept(TFloat type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadFloat();"; + } + + public string Accept(TDouble type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadDouble();"; + } + + public string Accept(TEnum type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadInt();"; + } + + public string Accept(TString type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadString();"; + } + + public string Accept(TBytes type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadArrayBuf();"; + } + + public string Accept(TText type, string bufName, string fieldName) + { + return $"{fieldName} = {bufName}.ReadString();"; + } + + public string Accept(TBean type, string bufVarName, string fieldName) + { + if (type.Bean.IsAbstractType) + { + return $"{fieldName} = {type.Bean.FullName}.deserialize({bufVarName});"; + } + else + { + return $"{fieldName} = new {type.Bean.FullName}({bufVarName});"; + } + } + + private string GetNewArray(TArray arrayType, string size) + { + switch (arrayType.ElementType) + { + case TByte _: return $"new Uint8Array({size})"; + case TShort _: + case TFshort _: return $"new Int16Array({size})"; + case TInt _: + case TFint _: return $"new Int32Array({size})"; + case TLong _: + case TFlong _: return $"new Int64Array({size})"; + case TFloat _: return $"new Float32Array({size})"; + case TDouble _: return $"new Float64Array({size})"; + default: return "[]"; + } + } + + private bool IsRawArrayElementType(TType elementType) + { + switch (elementType) + { + case TByte _: + case TShort _: + case TFshort _: + case TInt _: + case TFint _: + case TLong _: + case TFlong _: + case TFloat _: + case TDouble _: return true; + default: return false; + } + } + + public string Accept(TArray type, string bufVarName, string fieldName) + { + return $"{{ let n = Math.min({bufVarName}.ReadSize(), {bufVarName}.Size); {fieldName} = {GetNewArray(type, "n")}; for(let i = 0 ; i < n ; i++) {{ let _e :{type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, bufVarName, "_e")}; { (IsRawArrayElementType(type.ElementType) ? $"{fieldName}[i] = _e" : $"{fieldName}.push(_e)") } }} }}"; + } + + public string Accept(TList type, string bufVarName, string fieldName) + { + return $"{{ {fieldName} = []; for(let i = 0, n = {bufVarName}.ReadSize() ; i < n ; i++) {{ let _e :{type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, bufVarName, "_e")}; {fieldName}.push(_e) }} }}"; + } + + public string Accept(TSet type, string bufVarName, string fieldName) + { + return $"{{ {fieldName} = new {type.Apply(TypescriptDefineTypeName.Ins)}(); for(let i = 0, n = {bufVarName}.ReadSize() ; i < n ; i++) {{ let _e:{type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, bufVarName, "_e")} {fieldName}.add(_e);}}}}"; + } + + public string Accept(TMap type, string bufVarName, string fieldName) + { + return $"{{ {fieldName} = new {type.Apply(TypescriptDefineTypeName.Ins)}(); for(let i = 0, n = {bufVarName}.ReadSize() ; i < n ; i++) {{ let _k:{type.KeyType.Apply(TypescriptDefineTypeName.Ins)}; {type.KeyType.Apply(this, bufVarName, "_k")} let _v:{type.ValueType.Apply(TypescriptDefineTypeName.Ins)}; {type.ValueType.Apply(this, bufVarName, "_v")} {fieldName}.set(_k, _v); }} }}"; + + } + + public string Accept(TVector2 type, string bufVarName, string fieldName) + { + return $"{fieldName} = Vector2.from({bufVarName})"; + } + + public string Accept(TVector3 type, string bufVarName, string fieldName) + { + return $"{fieldName} = Vector3.from({bufVarName})"; + } + + public string Accept(TVector4 type, string bufVarName, string fieldName) + { + return $"{fieldName} = Vector4.from({bufVarName})"; + } + + public string Accept(TDateTime type, string bufVarName, string fieldName) + { + return $"{fieldName} = {bufVarName}.ReadInt();"; + } + } +} diff --git a/src/Luban.Job.Cfg/Source/TypeVisitors/TsUnderingDeserializeVisitor.cs b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeVisitor.cs similarity index 74% rename from src/Luban.Job.Cfg/Source/TypeVisitors/TsUnderingDeserializeVisitor.cs rename to src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeVisitor.cs index 346b5e3..ac3688a 100644 --- a/src/Luban.Job.Cfg/Source/TypeVisitors/TsUnderingDeserializeVisitor.cs +++ b/src/Luban.Job.Cfg/Source/TypeVisitors/TypescriptUnderingDeserializeVisitor.cs @@ -3,9 +3,9 @@ using Luban.Job.Common.TypeVisitors; namespace Luban.Job.Cfg.TypeVisitors { - class TsUnderingDeserializeVisitor : ITypeFuncVisitor + class TypescriptUnderingDeserializeVisitor : ITypeFuncVisitor { - public static TsUnderingDeserializeVisitor Ins { get; } = new TsUnderingDeserializeVisitor(); + public static TypescriptUnderingDeserializeVisitor Ins { get; } = new TypescriptUnderingDeserializeVisitor(); public string Accept(TBool type, string jsonVarName, string fieldName) { @@ -59,7 +59,7 @@ namespace Luban.Job.Cfg.TypeVisitors public string Accept(TEnum type, string jsonVarName, string fieldName) { - return $"{fieldName} = {jsonVarName} as number;"; + return $"{fieldName} = {jsonVarName};"; } public string Accept(TString type, string jsonVarName, string fieldName) @@ -97,7 +97,7 @@ namespace Luban.Job.Cfg.TypeVisitors } else { - return $"{{ {fieldName} = []; for(var _ele of {jsonVarName}) {{ let _e :{type.ElementType.Apply(TsDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.push(_e);}}}}"; + return $"{{ {fieldName} = []; for(var _ele of {jsonVarName}) {{ let _e :{type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.push(_e);}}}}"; } } @@ -109,7 +109,7 @@ namespace Luban.Job.Cfg.TypeVisitors } else { - return $"{{ {fieldName} = []; for(var _ele of {jsonVarName}) {{ let _e : {type.ElementType.Apply(TsDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.push(_e);}}}}"; + return $"{{ {fieldName} = []; for(var _ele of {jsonVarName}) {{ let _e : {type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.push(_e);}}}}"; } } @@ -121,29 +121,29 @@ namespace Luban.Job.Cfg.TypeVisitors } else { - return $"{{ {fieldName} = new {type.Apply(TsDefineTypeName.Ins)}(); for(var _ele of {jsonVarName}) {{ let _e:{type.ElementType.Apply(TsDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.add(_e);}}}}"; + return $"{{ {fieldName} = new {type.Apply(TypescriptDefineTypeName.Ins)}(); for(var _ele of {jsonVarName}) {{ let _e:{type.ElementType.Apply(TypescriptDefineTypeName.Ins)};{type.ElementType.Apply(this, "_ele", "_e")} {fieldName}.add(_e);}}}}"; } } public string Accept(TMap type, string jsonVarName, string fieldName) { - return $"{fieldName} = new {type.Apply(TsDefineTypeName.Ins)}(); for(var _entry_ of {jsonVarName}) {{ let _k:{type.KeyType.Apply(TsDefineTypeName.Ins)}; {type.KeyType.Apply(this, "_entry_[0]", "_k")} let _v:{type.ValueType.Apply(TsDefineTypeName.Ins)}; {type.ValueType.Apply(this, "_entry_[1]", "_v")} {fieldName}.set(_k, _v); }}"; + return $"{fieldName} = new {type.Apply(TypescriptDefineTypeName.Ins)}(); for(var _entry_ of {jsonVarName}) {{ let _k:{type.KeyType.Apply(TypescriptDefineTypeName.Ins)}; {type.KeyType.Apply(this, "_entry_[0]", "_k")} let _v:{type.ValueType.Apply(TypescriptDefineTypeName.Ins)}; {type.ValueType.Apply(this, "_entry_[1]", "_v")} {fieldName}.set(_k, _v); }}"; } public string Accept(TVector2 type, string jsonVarName, string fieldName) { - return $"{fieldName} = Vector2.fromJson({jsonVarName});"; + return $"{fieldName} = Vector2.from({jsonVarName});"; } public string Accept(TVector3 type, string jsonVarName, string fieldName) { - return $"{fieldName} = Vector3.fromJson({jsonVarName});"; + return $"{fieldName} = Vector3.from({jsonVarName});"; } public string Accept(TVector4 type, string jsonVarName, string fieldName) { - return $"{fieldName} = Vector4.fromJson({jsonVarName});"; + return $"{fieldName} = Vector4.from({jsonVarName});"; } public string Accept(TDateTime type, string jsonVarName, string fieldName) diff --git a/src/Luban.Job.Common/Source/Defs/TTypeTemplateCommonExtends.cs b/src/Luban.Job.Common/Source/Defs/TTypeTemplateCommonExtends.cs index 1a337b3..adb74b1 100644 --- a/src/Luban.Job.Common/Source/Defs/TTypeTemplateCommonExtends.cs +++ b/src/Luban.Job.Common/Source/Defs/TTypeTemplateCommonExtends.cs @@ -125,7 +125,7 @@ namespace Luban.Job.Common.Defs public static string TsDefineType(TType type) { - return type.Apply(TsDefineTypeName.Ins); + return type.Apply(TypescriptDefineTypeName.Ins); } public static string TsToString(string filedName, TType type) diff --git a/src/Luban.Job.Common/Source/TypeVisitors/TsDefineTypeName.cs b/src/Luban.Job.Common/Source/TypeVisitors/TypescriptDefineTypeName.cs similarity index 91% rename from src/Luban.Job.Common/Source/TypeVisitors/TsDefineTypeName.cs rename to src/Luban.Job.Common/Source/TypeVisitors/TypescriptDefineTypeName.cs index 528c8e7..53a1e1e 100644 --- a/src/Luban.Job.Common/Source/TypeVisitors/TsDefineTypeName.cs +++ b/src/Luban.Job.Common/Source/TypeVisitors/TypescriptDefineTypeName.cs @@ -2,9 +2,9 @@ using Luban.Job.Common.Types; namespace Luban.Job.Common.TypeVisitors { - public class TsDefineTypeName : ITypeFuncVisitor + public class TypescriptDefineTypeName : ITypeFuncVisitor { - public static TsDefineTypeName Ins { get; } = new TsDefineTypeName(); + public static TypescriptDefineTypeName Ins { get; } = new TypescriptDefineTypeName(); public string Accept(TBool type) { @@ -38,12 +38,12 @@ namespace Luban.Job.Common.TypeVisitors public string Accept(TLong type) { - return "number"; + return "bigint"; } public string Accept(TFlong type) { - return "number"; + return "bigint"; } public string Accept(TFloat type) @@ -106,7 +106,7 @@ namespace Luban.Job.Common.TypeVisitors public string Accept(TList type) { - return GetArrayType(type.ElementType); + return $"{type.ElementType.Apply(this)}[]"; } public string Accept(TSet type)