Mercurial > hg > orthanc-stone
comparison Resources/CodeGeneration/Graveyard/playground3.ts @ 495:6405435480ae bgo-commands-codegen
Fixed template to add dump capabilities + started work on an integrated TS/WASM test
author | bgo-osimis |
---|---|
date | Sat, 23 Feb 2019 14:14:32 +0100 |
parents | Resources/CodeGeneration/playground3.ts@8e7e151ef472 |
children |
comparison
equal
deleted
inserted
replaced
494:fc17251477d6 | 495:6405435480ae |
---|---|
1 /* | |
2 1 2 3 4 5 6 7 | |
3 12345678901234567890123456789012345678901234567890123456789012345678901234567890 | |
4 */ | |
5 | |
6 namespace VsolStuff222 { | |
7 export enum EnumMonth0 { | |
8 January, | |
9 February, | |
10 March | |
11 }; | |
12 | |
13 export class Message1 { | |
14 a: number; | |
15 b: string; | |
16 c: EnumMonth0; | |
17 d: boolean; | |
18 public StoneSerialize(): string { | |
19 let container: object = {}; | |
20 container['type'] = 'VsolStuff.Message1'; | |
21 container['value'] = this; | |
22 return JSON.stringify(container); | |
23 } | |
24 }; | |
25 | |
26 export class Message2 { | |
27 toto: string; | |
28 tata: Message1[]; | |
29 tutu: string[]; | |
30 titi: Map<string, string>; | |
31 lulu: Map<string, Message1>; | |
32 | |
33 public StoneSerialize(): string { | |
34 let container: object = {}; | |
35 container['type'] = 'VsolStuff.Message2'; | |
36 container['value'] = this; | |
37 return JSON.stringify(container); | |
38 } | |
39 }; | |
40 } | |
41 | |
42 function printf(value: any): void { | |
43 console.log(value) | |
44 } | |
45 | |
46 function main(): number { | |
47 | |
48 let msg1_0 = new VsolStuff.Message1(); | |
49 msg1_0.a = 42; | |
50 msg1_0.b = "Benjamin"; | |
51 msg1_0.c = VsolStuff.EnumMonth0.January; | |
52 msg1_0.d = true; | |
53 | |
54 let msg1_1 = new VsolStuff.Message1(); | |
55 msg1_1.a = 43; | |
56 msg1_1.b = "Sandrine"; | |
57 msg1_1.c = VsolStuff.EnumMonth0.March; | |
58 msg1_0.d = false; | |
59 | |
60 // std::string toto; | |
61 // std::vector<Message1> tata; | |
62 // std::vector<std::string> tutu; | |
63 // std::map<int32_t, std::string> titi; | |
64 // std::map<int32_t, Message1> lulu; | |
65 | |
66 let msg2_0 = new VsolStuff.Message2(); | |
67 msg2_0.toto = "Prout zizi"; | |
68 msg2_0.tata = new Array<VsolStuff.Message1>(); | |
69 msg2_0.tata.push(msg1_0); | |
70 msg2_0.tata.push(msg1_1); | |
71 msg2_0.tutu.push("Mercadet"); | |
72 msg2_0.tutu.push("Poisson");ing | |
73 msg2_0.titi["44"] = "key 44"; | |
74 msg2_0.titi["45"] = "key 45"; | |
75 msg2_0.lulu["54"] = msg1_1; | |
76 msg2_0.lulu["55"] = msg1_0; | |
77 let result:string = VsolStuff.StoneSerialize(msg2_0); | |
78 return 0; | |
79 } | |
80 | |
81 main() | |
82 | |
83 // string StoneSerialize_number(int32_t value) | |
84 // { | |
85 | |
86 // Json::Value result(value); | |
87 // return result; | |
88 // } | |
89 | |
90 // Json::Value StoneSerialize(double value) | |
91 // { | |
92 // Json::Value result(value); | |
93 // return result; | |
94 // } | |
95 | |
96 // Json::Value StoneSerialize(bool value) | |
97 // { | |
98 // Json::Value result(value); | |
99 // return result; | |
100 // } | |
101 | |
102 // Json::Value StoneSerialize(const std::string& value) | |
103 // { | |
104 // // the following is better than | |
105 // Json::Value result(value.data(),value.data()+value.size()); | |
106 // return result; | |
107 // } | |
108 | |
109 // template<typename T> | |
110 // Json::Value StoneSerialize(const std::map<std::string,T>& value) | |
111 // { | |
112 // Json::Value result(Json::objectValue); | |
113 | |
114 // for (std::map<std::string, T>::const_iterator it = value.cbegin(); | |
115 // it != value.cend(); ++it) | |
116 // { | |
117 // // it->first it->second | |
118 // result[it->first] = StoneSerialize(it->second); | |
119 // } | |
120 // return result; | |
121 // } | |
122 | |
123 // template<typename T> | |
124 // Json::Value StoneSerialize(const std::vector<T>& value) | |
125 // { | |
126 // Json::Value result(Json::arrayValue); | |
127 // for (size_t i = 0; i < value.size(); ++i) | |
128 // { | |
129 // result.append(StoneSerialize(value[i])); | |
130 // } | |
131 // return result; | |
132 // } | |
133 | |
134 // enum EnumMonth0 | |
135 // { | |
136 // January, | |
137 // February, | |
138 // March | |
139 // }; | |
140 | |
141 // std::string ToString(EnumMonth0 value) | |
142 // { | |
143 // switch(value) | |
144 // { | |
145 // case January: | |
146 // return "January"; | |
147 // case February: | |
148 // return "February"; | |
149 // case March: | |
150 // return "March"; | |
151 // default: | |
152 // { | |
153 // std::stringstream ss; | |
154 // ss << "Unrecognized EnumMonth0 value (" << static_cast<int64_t>(value) << ")"; | |
155 // throw std::runtime_error(ss.str()); | |
156 // } | |
157 // } | |
158 // } | |
159 | |
160 // void FromString(EnumMonth0& value, std::string strValue) | |
161 // { | |
162 // if (strValue == "January" || strValue == "EnumMonth0_January") | |
163 // { | |
164 // return January; | |
165 // } | |
166 // else if (strValue == "February" || strValue == "EnumMonth0_February") | |
167 // { | |
168 // return February; | |
169 // } | |
170 // #error Not implemented yet | |
171 // } | |
172 | |
173 // Json::Value StoneSerialize(const EnumMonth0& value) | |
174 // { | |
175 // return StoneSerialize(ToString(value)); | |
176 // } | |
177 // struct Message1 | |
178 // { | |
179 // int32_t a; | |
180 // std::string b; | |
181 // EnumMonth0 c; | |
182 // bool d; | |
183 // }; | |
184 | |
185 // struct Message2 | |
186 // { | |
187 // std::string toto; | |
188 // std::vector<Message1> tata; | |
189 // std::vector<std::string> tutu; | |
190 // std::map<std::string, std::string> titi; | |
191 // std::map<std::string, Message1> lulu; | |
192 // }; | |
193 | |
194 // Json::Value StoneSerialize(const Message1& value) | |
195 // { | |
196 // Json::Value result(Json::objectValue); | |
197 // result["a"] = StoneSerialize(value.a); | |
198 // result["b"] = StoneSerialize(value.b); | |
199 // result["c"] = StoneSerialize(value.c); | |
200 // result["d"] = StoneSerialize(value.d); | |
201 // return result; | |
202 // } | |
203 | |
204 // Json::Value StoneSerialize(const Message2& value) | |
205 // { | |
206 // Json::Value result(Json::objectValue); | |
207 // result["toto"] = StoneSerialize(value.toto); | |
208 // result["tata"] = StoneSerialize(value.tata); | |
209 // result["tutu"] = StoneSerialize(value.tutu); | |
210 // result["titi"] = StoneSerialize(value.titi); | |
211 // result["lulu"] = StoneSerialize(value.lulu); | |
212 // return result; | |
213 // } | |
214 // } | |
215 | |
216 // int main() | |
217 // { | |
218 // VsolStuff::Message1 msg1_0; | |
219 // msg1_0.a = 42; | |
220 // msg1_0.b = "Benjamin"; | |
221 // msg1_0.c = VsolStuff::January; | |
222 // msg1_0.d = true; | |
223 | |
224 // VsolStuff::Message1 msg1_1; | |
225 // msg1_1.a = 43; | |
226 // msg1_1.b = "Sandrine"; | |
227 // msg1_1.c = VsolStuff::March; | |
228 // msg1_0.d = false; | |
229 | |
230 // // std::string toto; | |
231 // // std::vector<Message1> tata; | |
232 // // std::vector<std::string> tutu; | |
233 // // std::map<int32_t, std::string> titi; | |
234 // // std::map<int32_t, Message1> lulu; | |
235 | |
236 // VsolStuff::Message2 msg2_0; | |
237 // msg2_0.toto = "Prout zizi"; | |
238 // msg2_0.tata.push_back(msg1_0); | |
239 // msg2_0.tata.push_back(msg1_1); | |
240 // msg2_0.tutu.push_back("Mercadet"); | |
241 // msg2_0.tutu.push_back("Poisson"); | |
242 // msg2_0.titi["44"] = "key 44"; | |
243 // msg2_0.titi["45"] = "key 45"; | |
244 // msg2_0.lulu["54"] = msg1_1; | |
245 // msg2_0.lulu["55"] = msg1_0; | |
246 // auto result = VsolStuff::StoneSerialize(msg2_0); | |
247 // auto resultStr = result.toStyledString(); | |
248 | |
249 // Json::Value readValue; | |
250 | |
251 // Json::CharReaderBuilder builder; | |
252 // Json::CharReader* reader = builder.newCharReader(); | |
253 // std::string errors; | |
254 | |
255 // bool ok = reader->parse( | |
256 // resultStr.c_str(), | |
257 // resultStr.c_str() + resultStr.size(), | |
258 // &readValue, | |
259 // &errors | |
260 // ); | |
261 // delete reader; | |
262 | |
263 // if (!ok) | |
264 // { | |
265 // std::stringstream ss; | |
266 // ss << "Json parsing error: " << errors; | |
267 // throw std::runtime_error(ss.str()); | |
268 // } | |
269 // std::cout << readValue.get("toto", "Default Value").asString() << std::endl; | |
270 // return 0; | |
271 // } | |
272 | |
273 | |
274 } | |
275 |