> vecmap;
313 |
314 | ProtoArchiver<> ar, ar2;
315 | // if (ar.ParseFromString(data)) {
316 | if (::deserialize(ar, data)) {
317 | ar >> p1 >> p2 >> p3;
318 | ar >> pvec;
319 | ar >> pmap;
320 | ar >> vecmap;
321 | ar >> ar2;
322 | }
323 |
324 | std::cout << "\n------ p1 ----------\n";
325 | {
326 | std::cout << p1.ShortDebugString() << std::endl;
327 | }
328 | std::cout << "\n------ p2 ----------\n";
329 | {
330 | std::cout << p2.ShortDebugString() << std::endl;
331 | }
332 | std::cout << "\n------ p3 ----------\n";
333 | {
334 | std::cout << p3.ShortDebugString() << std::endl;
335 | }
336 |
337 | std::cout << "\n------ vector ----------\n";
338 | {
339 | for (auto &p : pvec) {
340 | std::cout << p.ShortDebugString() << std::endl;
341 | }
342 | }
343 |
344 | std::cout << "\n------ map
----------\n";
345 | {
346 | for (auto &v : pmap) {
347 | std::cout << v.first << " : " << v.second.ShortDebugString() << std::endl;
348 | }
349 | }
350 |
351 | std::cout << "\n------ vector> ----------\n";
352 | {
353 | for (auto &item : vecmap) {
354 | for (auto &v: item)
355 | std::cout << v.first << " : " << v.second.ShortDebugString() << std::endl;
356 | std::cout << std::endl;
357 | }
358 | }
359 |
360 | std::cout << "\n------ archiver ----------\n";
361 | {
362 | std::cout << ar2.ShortDebugString() << std::endl;
363 | }
364 | }
365 | }
366 |
367 | int main(int argc, const char* argv[]) {
368 | int count = 1;
369 | if (argc > 1)
370 | count = std::atoi(argv[1]);
371 |
372 | for (int i = 0; i < count; ++i) {
373 | demo_basic();
374 | demo_stl();
375 | demo_userdefined();
376 | demo_archiver();
377 | }
378 | }
--------------------------------------------------------------------------------
/example/demo_serialize_dyn.cpp:
--------------------------------------------------------------------------------
1 | #include "tinyreflection.h"
2 | #include "tinyserializer.h"
3 | #include "tinyserializer_proto.h"
4 | #include "tinyserializer_proto_dyn.h"
5 |
6 | #include "player.pb.h"
7 |
8 | //
9 | // Demo for Scalar
10 | //
11 | void demo_basic() {
12 |
13 | std::cout << "\n========" << __PRETTY_FUNCTION__ << std::endl;
14 |
15 | std::cout << "\n------ int ----------\n";
16 | {
17 | uint32_t v1 = 1024;
18 | std::string data = serialize(v1);
19 |
20 | uint64_t v2 = 0;
21 | deserialize(v2, data);
22 |
23 | std::cout << v2 << std::endl;
24 | }
25 |
26 | std::cout << "\n------ float ----------\n";
27 | {
28 | double v1 = 3.1415926;
29 | std::string data = serialize(v1);
30 |
31 | float v2 = 0;
32 | deserialize(v2, data);
33 |
34 | std::cout << v2 << std::endl;
35 | }
36 |
37 | std::cout << "\n------ string ----------\n";
38 | {
39 | std::string v1 = "Hello David++!";
40 | std::string data = serialize(v1);
41 |
42 | std::string v2;
43 | if (deserialize(v2, data))
44 | std::cout << v2 << std::endl;
45 | else
46 | std::cout << "error happens !" << std::endl;
47 | }
48 |
49 | std::cout << "\n------ proto ----------\n";
50 | {
51 | PlayerProto p1;
52 | p1.set_id(1024);
53 | p1.set_name("david");
54 | p1.add_quests(1);
55 | p1.add_quests(2);
56 | p1.mutable_weapon()->set_type(2);
57 | p1.mutable_weapon()->set_name("Sword");
58 |
59 |
60 | std::string data = serialize(p1);
61 |
62 | PlayerProto p2;
63 | if (deserialize(p2, data))
64 | std::cout << p2.ShortDebugString() << std::endl;
65 | else
66 | std::cout << "error happens !" << std::endl;
67 | }
68 | }
69 |
70 | //
71 | // Demo for STL container
72 | //
73 | void demo_stl() {
74 | std::cout << "\n========" << __PRETTY_FUNCTION__ << std::endl;
75 |
76 | PlayerProto p;
77 | p.set_id(1024);
78 | p.set_name("david");
79 | p.add_quests(1);
80 | p.add_quests(2);
81 | p.mutable_weapon()->set_type(2);
82 | p.mutable_weapon()->set_name("Sword");
83 |
84 | std::cout << "\n------ vector ----------\n";
85 | {
86 | std::vector v1 = {1, 2, 3, 4, 5, 6};
87 | std::string data = serialize(v1);
88 |
89 | std::vector v2;
90 | deserialize(v2, data);
91 |
92 | for (auto &v : v2)
93 | std::cout << v << ",";
94 | std::cout << std::endl;
95 | }
96 |
97 | std::cout << "\n------ map ----------\n";
98 | {
99 | std::map v1 = {
100 | {1024, p},
101 | {1025, p},
102 | {1026, p},
103 | };
104 |
105 | std::string data = serialize(v1);
106 |
107 | std::map v2;
108 | deserialize(v2, data);
109 |
110 | for (auto &v : v2)
111 | std::cout << v.first << " - " << v.second.ShortDebugString() << std::endl;
112 | }
113 |
114 | std::cout << "\n------ map> ----------\n";
115 | {
116 | std::map> v1 = {
117 | {1024, {p, p, p}},
118 | {1025, {p, p}},
119 | {1026, {p}},
120 | };
121 |
122 | std::string data = serialize(v1);
123 |
124 | std::map> v2;
125 | deserialize(v2, data);
126 |
127 | for (auto &v : v2) {
128 | std::cout << v.first << std::endl;
129 | for (auto& player : v.second)
130 | std::cout << "\t - " << player.ShortDebugString() << std::endl;
131 | }
132 | }
133 | }
134 |
135 | //
136 | // Demo for User-Defined
137 | //
138 |
139 | struct Weapon {
140 | uint32_t type = 0;
141 | std::string name = "";
142 | };
143 |
144 | struct Player {
145 | uint32_t id = 0;
146 | std::string name = "";
147 | std::vector quests;
148 | Weapon weapon;
149 | std::map weapons;
150 | std::map> weapons_map;
151 |
152 | void dump() const {
153 | std::cout << "id = " << id << std::endl;
154 | std::cout << "name = " << name << std::endl;
155 |
156 | std::cout << "quests = [";
157 | for (auto v : quests)
158 | std::cout << v << ",";
159 | std::cout << "]" << std::endl;
160 |
161 | std::cout << "weapon = {" << weapon.type << "," << weapon.name << "}" << std::endl;
162 |
163 | std::cout << "weapons_map = {" << std::endl;
164 | for (auto &kv : weapons_map) {
165 | std::cout << "\t" << kv.first << ": [";
166 | for (auto &p : kv.second) {
167 | std::cout << "{" << p.type << "," << p.name << "},";
168 | }
169 | std::cout << "]" << std::endl;
170 | }
171 | std::cout << "}" << std::endl;
172 | }
173 |
174 | void init() {
175 | id = 1024;
176 | name = "david";
177 | quests.push_back(1);
178 | quests.push_back(2);
179 |
180 | weapon.type = 0;
181 | weapon.name = "Sword";
182 |
183 | for (uint32_t i = 0; i < 3; i++) {
184 | weapons[i].type = i;
185 | weapons[i].name = "Shield";
186 | }
187 |
188 | Weapon w;
189 | w.type = 22;
190 | w.name = "Blade";
191 | weapons_map = {
192 | {1, {w, w, w}},
193 | {2, {w, w, w}},
194 | };
195 |
196 | }
197 | };
198 |
199 | // Struct -> Proto Mapping
200 | RUN_ONCE(Mapping) {
201 |
202 | ProtoMappingFactory::instance().declare("Weapon")
203 | .property("type", &Weapon::type, 1)
204 | .property("name", &Weapon::name, 2);
205 |
206 | ProtoMappingFactory::instance().declare("Player", "PlayerDynProto")
207 | .property("id", &Player::id, 1)
208 | .property("name", &Player::name, 2)
209 | .property("quests", &Player::quests, 3)
210 | .property("weapon", &Player::weapon, 4)
211 | .property("weapon2", &Player::weapons, 5)
212 | .property("weapons_map", &Player::weapons_map, 6);
213 |
214 | // MUST!!! CREATE DESCRIPTORS
215 | ProtoMappingFactory::instance().createAllProtoDescriptor();
216 | }
217 |
218 | void demo_userdefined() {
219 | std::cout << "\n========" << __PRETTY_FUNCTION__ << std::endl;
220 |
221 | try {
222 | std::cout << "\n------ Proto created ----------\n";
223 | {
224 | ProtoMappingFactory::instance().createAllProtoDefine();
225 | }
226 |
227 | std::cout << "\n------ Weapon ----------\n";
228 | {
229 | Weapon w;
230 | w.type = 22;
231 | w.name = "Blade";
232 |
233 | std::string data = serialize(w);
234 |
235 | Weapon w2;
236 | deserialize(w2, data);
237 | std::cout << w2.type << " - " << w2.name << std::endl;
238 | }
239 |
240 | std::cout << "\n------ Player ----------\n";
241 | {
242 | Player p;
243 | p.init();
244 |
245 | std::string data = serialize(p);
246 |
247 | Player p2;
248 | deserialize(p2, data);
249 | p2.dump();
250 | }
251 | } catch (const std::exception& e) {
252 | std::cout << "Error Happens: " << e.what() << std::endl;
253 | }
254 | }
255 |
256 | //
257 | // Demo for Archiver
258 | //
259 | void demo_archiver() {
260 | std::cout << "\n========" << __PRETTY_FUNCTION__ << std::endl;
261 |
262 | std::string data;
263 |
264 | // serialize
265 | {
266 | PlayerProto p;
267 | p.set_id(1024);
268 | p.set_name("david");
269 |
270 | std::vector pvec{p, p, p};
271 |
272 | std::map pmap{
273 | {1, p},
274 | {2, p},
275 | {3, p}
276 | };
277 |
278 | std::vector > vecmap{pmap, pmap, pmap};
279 |
280 | ProtoArchiver ar;
281 | ar << p << p << p; // support: protobuf generated
282 | ar << pvec; // support: std::vector
283 | ar << pmap; // support: std::map
284 | ar << vecmap; // support: composite of STL container
285 | ar << ar; // support: archiver self ? YES!
286 |
287 | // ar.SerializeToString(&data);
288 | data = serialize(ar);
289 | }
290 |
291 | // deserialize
292 | {
293 | PlayerProto p1, p2, p3;
294 | std::vector pvec;
295 | std::map pmap;
296 | std::vector > vecmap;
297 |
298 | ProtoArchiver ar, ar2;
299 | // if (ar.ParseFromString(data)) {
300 | if (::deserialize(ar, data)) {
301 | ar >> p1 >> p2 >> p3;
302 | ar >> pvec;
303 | ar >> pmap;
304 | ar >> vecmap;
305 | ar >> ar2;
306 | }
307 |
308 | std::cout << "\n------ p1 ----------\n";
309 | {
310 | std::cout << p1.ShortDebugString() << std::endl;
311 | }
312 | std::cout << "\n------ p2 ----------\n";
313 | {
314 | std::cout << p2.ShortDebugString() << std::endl;
315 | }
316 | std::cout << "\n------ p3 ----------\n";
317 | {
318 | std::cout << p3.ShortDebugString() << std::endl;
319 | }
320 |
321 | std::cout << "\n------ vector ----------\n";
322 | {
323 | for (auto &p : pvec) {
324 | std::cout << p.ShortDebugString() << std::endl;
325 | }
326 | }
327 |
328 | std::cout << "\n------ map
----------\n";
329 | {
330 | for (auto &v : pmap) {
331 | std::cout << v.first << " : " << v.second.ShortDebugString() << std::endl;
332 | }
333 | }
334 |
335 | std::cout << "\n------ vector> ----------\n";
336 | {
337 | for (auto &item : vecmap) {
338 | for (auto &v: item)
339 | std::cout << v.first << " : " << v.second.ShortDebugString() << std::endl;
340 | std::cout << std::endl;
341 | }
342 | }
343 |
344 | std::cout << "\n------ archiver ----------\n";
345 | {
346 | std::cout << ar2.ShortDebugString() << std::endl;
347 | }
348 | }
349 | }
350 |
351 | int main(int argc, const char* argv[]) {
352 | int count = 1;
353 | if (argc > 1)
354 | count = std::atoi(argv[1]);
355 |
356 | for (int i = 0; i < count; ++i) {
357 | demo_basic();
358 | demo_stl();
359 | demo_userdefined();
360 | demo_archiver();
361 | }
362 | }
--------------------------------------------------------------------------------
/example/player.h:
--------------------------------------------------------------------------------
1 | #ifndef TINYWORLD_PLAYER_H
2 | #define TINYWORLD_PLAYER_H
3 |
4 | #include "tinyworld.h"
5 | #include "tinyorm.h"
6 | #include "player.pb.h"
7 |
8 | struct Weapon {
9 | uint32_t type = 0;
10 | std::string name = "";
11 |
12 | std::string serialize() const {
13 | WeaponProto proto;
14 | proto.set_type(type);
15 | proto.set_name(name);
16 | return proto.SerializeAsString();
17 | }
18 |
19 | bool deserialize(const std::string &data) {
20 | WeaponProto proto;
21 | if (proto.ParseFromString(data)) {
22 | type = proto.type();
23 | name = proto.name();
24 | return true;
25 | }
26 | return false;
27 | }
28 | };
29 |
30 | //
31 | // Player -> PLAYER
32 | //
33 | struct Player {
34 | //
35 | // Proto序列化约束
36 | //
37 | std::string serialize() const {
38 | PlayerProto4Table proto;
39 | proto.set_id(id);
40 | proto.set_name(name);
41 | proto.set_age(age);
42 | proto.set_weaon(::serialize(weapon));
43 | proto.set_weapns(::serialize(weapons));
44 | return proto.SerializeAsString();
45 | }
46 |
47 | bool deserialize(const std::string &data) {
48 | PlayerProto4Table proto;
49 | if (proto.ParseFromString(data)) {
50 | id = proto.id();
51 | name = proto.name();
52 | age = proto.age();
53 | ::deserialize(weapon, proto.weaon());
54 | ::deserialize(weapons, proto.weapns());
55 |
56 | return true;
57 | }
58 | return false;
59 | }
60 |
61 | // ...
62 | uint32_t id = 0;
63 | std::string name;
64 | uint8_t age = 0;
65 |
66 | // 整型
67 | int8_t m_int8 = 0;
68 | uint8_t m_uint8 = 0;
69 | int16_t m_int16 = 0;
70 | uint16_t m_uint16 = 0;
71 | int32_t m_int32 = 0;
72 | uint32_t m_uint32 = 0;
73 | int64_t m_int64 = 0;
74 | uint64_t m_uint64 = 0;
75 |
76 | // 浮点
77 | float m_float = 0.0;
78 | double m_double = 0.0;
79 |
80 | // 布尔
81 | bool m_bool = false;
82 |
83 | // 字符串
84 | std::string m_string;
85 |
86 | // 二进制
87 | std::string m_bytes;
88 | std::string m_bytes_tiny;
89 | std::string m_bytes_medium;
90 | std::string m_bytes_long;
91 |
92 | // 复合对象
93 | Weapon weapon;
94 | std::vector weapons;
95 |
96 | void init() {
97 | id = 1024;
98 | name = "david";
99 | age = 30;
100 |
101 | // 整型
102 | m_int8 = 1;
103 | m_uint8 = 2;
104 | m_int16 = 3;
105 | m_uint16 = 4;
106 | m_int32 = 5;
107 | m_uint32 = 6;
108 | m_int64 = 7;
109 | m_uint64 = 8;
110 | // 浮点
111 | m_float = 10.11;
112 | m_double = 20.22;
113 | m_bool = true;
114 |
115 | m_string = "string";
116 |
117 |
118 | m_bytes = "bytes";
119 | m_bytes_tiny = "tiny...bytes";
120 | m_bytes_medium = "medium...bytes";
121 | m_bytes_long = "long...bytes";
122 | weapon.type = 24;
123 | weapon.name = "sword";
124 | weapons = {weapon, weapon, weapon};
125 | }
126 | };
127 |
128 | // 在cpp中定义一次即可
129 | RUN_ONCE(Player) {
130 | TableFactory::instance().table("PLAYER")
131 | .field(&Player::id, "ID", FieldType::UINT32)
132 | .field(&Player::name, "NAME", FieldType::VCHAR, "david", 32)
133 | .field(&Player::age, "AGE", FieldType::UINT8, "30")
134 |
135 | .field(&Player::m_int8, "M_INT8", FieldType::INT8)
136 | .field(&Player::m_int16, "M_INT16", FieldType::INT16)
137 | .field(&Player::m_int32, "M_INT32", FieldType::INT32)
138 | .field(&Player::m_int64, "M_INT64", FieldType::INT64)
139 | .field(&Player::m_uint8, "M_UINT8", FieldType::UINT8)
140 | .field(&Player::m_uint16, "M_UINT16", FieldType::UINT16)
141 | .field(&Player::m_uint32, "M_UINT32", FieldType::UINT32)
142 | .field(&Player::m_uint64, "M_UINT64", FieldType::UINT64)
143 |
144 | .field(&Player::m_bool, "M_BOOL", FieldType::BOOL)
145 | .field(&Player::m_float, "M_FLOAT", FieldType::FLOAT)
146 | .field(&Player::m_double, "M_DOUBLE", FieldType::DOUBLE)
147 |
148 | .field(&Player::m_string, "M_STRING", FieldType::STRING)
149 |
150 | .field(&Player::m_bytes, "M_BYTES", FieldType::BYTES)
151 | .field(&Player::m_bytes_tiny, "M_BYTES_S", FieldType::BYTES_TINY)
152 | .field(&Player::m_bytes_medium, "M_BYTES_M", FieldType::BYTES_MEDIUM)
153 | .field(&Player::m_bytes_long, "M_BYTES_L", FieldType::BYTES_LONG)
154 |
155 | .field(&Player::weapon, "OBJ1", FieldType::OBJECT)
156 | .field(&Player::weapons, "OBJ2", FieldType::OBJECT)
157 | .key("ID")
158 | .index("NAME");
159 | }
160 |
161 | std::ostream &operator<<(std::ostream &os, const Player &p) {
162 | os << "-------- Player:(" << p.id << "," << p.name << ")------" << std::endl;
163 | os << "- m_int8 = " << (int) p.m_int8 << std::endl;
164 | os << "- m_int16 = " << p.m_int16 << std::endl;
165 | os << "- m_int32 = " << p.m_int32 << std::endl;
166 | os << "- m_int64 = " << p.m_int64 << std::endl;
167 | os << "- m_uint8 = " << (int) p.m_uint8 << std::endl;
168 | os << "- m_uint16 = " << p.m_uint16 << std::endl;
169 | os << "- m_uint32 = " << p.m_uint32 << std::endl;
170 | os << "- m_uint64 = " << p.m_uint64 << std::endl;
171 | os << "- m_float = " << p.m_float << std::endl;
172 | os << "- m_double = " << p.m_double << std::endl;
173 | os << "- m_bool = " << p.m_bool << std::endl;
174 | os << "- m_string = " << p.m_string << std::endl;
175 |
176 | os << "- m_bytes = " << p.m_bytes.size() << std::endl;
177 | os << "- m_bytes_tiny = " << p.m_bytes_tiny.size() << std::endl;
178 | os << "- m_bytes_medium = " << p.m_bytes_medium.size() << std::endl;
179 | os << "- m_bytes_long = " << p.m_bytes_long.size() << std::endl;
180 |
181 | os << "- weapon = {" << p.weapon.type << "," << p.weapon.name << "}" << std::endl;
182 | os << "- weapons = " << p.weapons.size() << std::endl;
183 |
184 | return os;
185 | }
186 |
187 | #endif //TINYWORLD_PLAYER_H
--------------------------------------------------------------------------------
/example/player.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto2";
2 |
3 | //
4 | // 定义protobuf消息
5 | //
6 |
7 | message WeaponProto {
8 | optional uint32 type = 1;
9 | optional string name = 2;
10 | }
11 |
12 | message PlayerProto {
13 | // Scalar: 1 vs N
14 | optional uint32 id = 1;
15 | optional string name = 2;
16 | repeated uint32 quests = 3;
17 |
18 | // Nested: 1 vs N
19 | optional WeaponProto weapon = 4;
20 | repeated WeaponProto weapons = 5;
21 |
22 | // STL
23 | optional bytes weapons_map = 6;
24 | }
25 |
26 | message PlayerProto4Table {
27 | optional uint32 id = 1;
28 | optional bytes name = 2;
29 | optional uint32 age = 3;
30 |
31 | optional bytes weaon = 4;
32 | optional bytes weapns = 5;
33 | }
--------------------------------------------------------------------------------
/example/tinyobj/tinyobj.cpp:
--------------------------------------------------------------------------------
1 | #include "tinyobj.h"
2 |
3 | void initTinyObjectSystem()
4 | {
5 | }
6 |
7 | #include "tinyplayer.orm.h"
8 |
--------------------------------------------------------------------------------
/example/tinyobj/tinyobj.h:
--------------------------------------------------------------------------------
1 | #ifndef TINYWORLD_TINYOBJ_H
2 | #define TINYWORLD_TINYOBJ_H
3 |
4 | #include "tinyworld.h"
5 |
6 | #include
7 | #include
8 | #include