|
491
|
1 /*
|
|
|
2 1 2 3 4 5 6 7
|
|
|
3 12345678901234567890123456789012345678901234567890123456789012345678901234567890
|
|
|
4 */
|
|
|
5
|
|
|
6 namespace {{rootName}}
|
|
|
7 {
|
|
|
8 function StoneCheckSerializedValueType(value: any, typeStr: string)
|
|
|
9 {
|
|
|
10 StoneCheckSerializedValueTypeGeneric(value);
|
|
|
11
|
|
|
12 if (value['type'] != typeStr)
|
|
|
13 {
|
|
|
14 throw new Error(
|
|
|
15 `Cannot deserialize type ${value['type']} into ${typeStr}`);
|
|
490
|
16 }
|
|
491
|
17 }
|
|
|
18
|
|
|
19 function isString(val: any) :boolean
|
|
|
20 {
|
|
|
21 return ((typeof val === 'string') || (val instanceof String));
|
|
|
22 }
|
|
|
23
|
|
|
24 function StoneCheckSerializedValueTypeGeneric(value: any)
|
|
|
25 {
|
|
|
26 if ( (!('type' in value)) || (!isString(value)) )
|
|
|
27 {
|
|
|
28 throw new Error(
|
|
|
29 "Cannot deserialize value ('type' key invalid)");
|
|
490
|
30 }
|
|
491
|
31 }
|
|
|
32
|
|
|
33 // end of generic methods
|
|
|
34 {% for enum in enums%}
|
|
|
35 export enum {{enum['name']}} {
|
|
|
36 {% for key in enumDict.keys()%}
|
|
|
37 {{key}},
|
|
|
38 {%endfor%}
|
|
|
39 };
|
|
|
40 {%endfor%}
|
|
|
41
|
|
|
42 export class Message1 {
|
|
|
43 a: number;
|
|
|
44 b: string;
|
|
|
45 c: EnumMonth0;
|
|
|
46 d: boolean;
|
|
|
47 public StoneSerialize(): string {
|
|
|
48 let container: object = {};
|
|
|
49 container['type'] = 'VsolStuff.Message1';
|
|
|
50 container['value'] = this;
|
|
|
51 return JSON.stringify(container);
|
|
|
52 }
|
|
|
53 };
|
|
490
|
54
|
|
491
|
55 export class Message2 {
|
|
|
56 constructor()
|
|
|
57 {
|
|
|
58 this.tata = new Array<Message1>();
|
|
|
59 this.tutu = new Array<string>();
|
|
|
60 this.titi = new Map<string, string>();
|
|
|
61 this.lulu = new Map<string, Message1>();
|
|
|
62 }
|
|
|
63 toto: string;
|
|
|
64 tata: Message1[];
|
|
|
65 tutu: string[];
|
|
|
66 titi: Map<string, string>;
|
|
|
67 lulu: Map<string, Message1>;
|
|
|
68
|
|
|
69 public StoneSerialize(): string {
|
|
|
70 let container: object = {};
|
|
|
71 container['type'] = 'VsolStuff.Message2';
|
|
|
72 container['value'] = this;
|
|
|
73 return JSON.stringify(container);
|
|
|
74 }
|
|
|
75 public static StoneDeserialize(valueStr: string) : Message2
|
|
|
76 {
|
|
|
77 let value: any = JSON.parse(valueStr);
|
|
|
78 StoneCheckSerializedValueType(value, "VsolStuff.Message2");
|
|
|
79 let result: Message2 = value['value'] as Message2;
|
|
|
80 return result;
|
|
|
81 }
|
|
|
82 };
|
|
|
83
|
|
|
84 export interface IDispatcher
|
|
|
85 {
|
|
|
86 HandleMessage1(value: Message1): boolean;
|
|
|
87 HandleMessage2(value: Message2): boolean;
|
|
|
88 };
|
|
490
|
89
|
|
491
|
90 /** Service function for StoneDispatchToHandler */
|
|
|
91 export function StoneDispatchJsonToHandler(
|
|
|
92 jsonValueStr: string, dispatcher: IDispatcher): boolean
|
|
|
93 {
|
|
|
94 let jsonValue: any = JSON.parse(jsonValueStr);
|
|
|
95 StoneCheckSerializedValueTypeGeneric(jsonValue);
|
|
|
96 let type: string = jsonValue["type"];
|
|
|
97 if (type == "")
|
|
|
98 {
|
|
|
99 // this should never ever happen
|
|
|
100 throw new Error("Caught empty type while dispatching");
|
|
|
101 }
|
|
|
102 else if (type == "VsolStuff.Message1")
|
|
|
103 {
|
|
|
104 let value = jsonValue["value"] as Message1;
|
|
|
105 return dispatcher.HandleMessage1(value);
|
|
|
106 }
|
|
|
107 else if (type == "VsolStuff.Message2")
|
|
|
108 {
|
|
|
109 let value = jsonValue["value"] as Message2;
|
|
|
110 return dispatcher.HandleMessage2(value);
|
|
|
111 }
|
|
|
112 else
|
|
|
113 {
|
|
|
114 return false;
|
|
|
115 }
|
|
|
116 }
|
|
490
|
117
|
|
491
|
118 /** Takes a serialized type and passes this to the dispatcher */
|
|
|
119 export function StoneDispatchToHandler(
|
|
|
120 strValue: string, dispatcher: IDispatcher): boolean
|
|
|
121 {
|
|
|
122 let jsonValue: any = JSON.parse(strValue)
|
|
|
123 return StoneDispatchJsonToHandler(jsonValue, dispatcher);
|
|
|
124 }
|
|
|
125 }
|
