Debian Codegraph @

LspCpp/include/LibLsp/JsonRpc/serializer.h

raw
1 #pragma once
2
3 #include "macro_map.h"
4 #include <cstdint>
5 #include <cassert>
6 #include <memory>
7 #include <string>
8 #include <type_traits>
9 #include <vector>
10 #include <functional>
11 #include <map>
12 #include <algorithm>
13
14 #include "optionalVersion.h"
15
16 struct AbsolutePath;
17
18 enum class SerializeFormat
19 {
20 Json,
21 MessagePack
22 };
23
24 // A tag type that can be used to write `null` to json.
25 struct JsonNull
26 {
27 void swap(JsonNull& arg) noexcept;
28 };
29
30 class Reader
31 {
32 public:
33 virtual ~Reader()
34 {
35 }
36 virtual SerializeFormat Format() const = 0;
37
38 virtual bool IsBool() = 0;
39 virtual bool IsNull() = 0;
40 virtual bool IsArray() = 0;
41 virtual bool IsInt() = 0;
42 virtual bool IsInt64() = 0;
43 virtual bool IsUint64() = 0;
44 virtual bool IsDouble() = 0;
45 virtual bool IsNumber() = 0;
46 virtual bool IsString() = 0;
47
48 virtual void GetNull() = 0;
49 virtual bool GetBool() = 0;
50 virtual int GetInt() = 0;
51 virtual uint32_t GetUint32() = 0;
52 virtual int64_t GetInt64() = 0;
53 virtual uint64_t GetUint64() = 0;
54 virtual double GetDouble() = 0;
55 virtual std::string GetString() = 0;
56
57 virtual bool HasMember(char const* x) = 0;
58 virtual std::unique_ptr<Reader> operator[](char const* x) = 0;
59 virtual void IterMap(std::function<void(char const*, Reader&)> fn) = 0;
60 virtual void IterArray(std::function<void(Reader&)> fn) = 0;
61 virtual void DoMember(char const* name, std::function<void(Reader&)> fn) = 0;
62 virtual std::string ToString() const = 0;
63 };
64
65 class Writer
66 {
67 public:
68 virtual ~Writer()
69 {
70 }
71 virtual SerializeFormat Format() const = 0;
72
73 virtual void Null() = 0;
74 virtual void Bool(bool x) = 0;
75 virtual void Int(int x) = 0;
76 virtual void Uint32(uint32_t x) = 0;
77 virtual void Int64(int64_t x) = 0;
78 virtual void Uint64(uint64_t x) = 0;
79 virtual void Double(double x) = 0;
80 virtual void String(char const* x) = 0;
81 virtual void String(char const* x, size_t len) = 0;
82 virtual void StartArray(size_t) = 0;
83 virtual void EndArray() = 0;
84 virtual void StartObject() = 0;
85 virtual void EndObject() = 0;
86 virtual void Key(char const* name) = 0;
87 };
88
89 struct optionals_mandatory_tag
90 {
91 };
92
93 #define REFLECT_MEMBER_START() ReflectMemberStart(visitor, value)
94 #define REFLECT_MEMBER_END() ReflectMemberEnd(visitor, value);
95 #define REFLECT_MEMBER_END1(value) ReflectMemberEnd(visitor, value);
96 #define REFLECT_MEMBER(name) ReflectMember(visitor, #name, value.name)
97 #define REFLECT_MEMBER_OPTIONALS(name) ReflectMember(visitor, #name, value.name, optionals_mandatory_tag {})
98 #define REFLECT_MEMBER2(name, value) ReflectMember(visitor, name, value)
99
100 #define MAKE_REFLECT_TYPE_PROXY(type_name) MAKE_REFLECT_TYPE_PROXY2(type_name, std::underlying_type<type_name>::type)
101 #define MAKE_REFLECT_TYPE_PROXY2(type, as_type) \
102 inline void Reflect(Reader& visitor, type& value) \
103 { \
104 as_type value0; \
105 ::Reflect(visitor, value0); \
106 value = static_cast<type>(value0); \
107 } \
108 inline void Reflect(Writer& visitor, type& value) \
109 { \
110 auto value0 = static_cast<as_type>(value); \
111 ::Reflect(visitor, value0); \
112 }
113
114 #define _MAPPABLE_REFLECT_MEMBER(name) REFLECT_MEMBER(name);
115 #define _MAPPABLE_REFLECT_MEMBER_OPTIONALS(name) REFLECT_MEMBER_OPTIONALS(name);
116
117 #define MAKE_REFLECT_EMPTY_STRUCT(type, ...) \
118 template<typename TVisitor> \
119 void Reflect(TVisitor& visitor, type& value) \
120 { \
121 REFLECT_MEMBER_START(); \
122 REFLECT_MEMBER_END(); \
123 }
124
125 #define MAKE_REFLECT_STRUCT(type, ...) \
126 template<typename TVisitor> \
127 void Reflect(TVisitor& visitor, type& value) \
128 { \
129 REFLECT_MEMBER_START(); \
130 MACRO_MAP(_MAPPABLE_REFLECT_MEMBER, __VA_ARGS__) \
131 REFLECT_MEMBER_END(); \
132 }
133
134 #define _MAPPABLE_SWAP_MEMBER(name) std::swap(name, arg.name);
135
136 #define MAKE_SWAP_METHOD(type, ...) \
137 void swap(type& arg) noexcept \
138 { \
139 MACRO_MAP(_MAPPABLE_SWAP_MEMBER, __VA_ARGS__) \
140 }
141
142 #define MAKE_REFLECT_STRUCT_OPTIONALS_MANDATORY(type, ...) \
143 template<typename TVisitor> \
144 void Reflect(TVisitor& visitor, type& value) \
145 { \
146 REFLECT_MEMBER_START(); \
147 MACRO_MAP(_MAPPABLE_REFLECT_MEMBER_OPTIONALS, __VA_ARGS__) \
148 REFLECT_MEMBER_END(); \
149 }
150
151 // clang-format off
152 // Config has many fields, we need to support at least its number of fields.
153 #define NUM_VA_ARGS_IMPL(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,N,...) N
154 #define NUM_VA_ARGS(...) NUM_VA_ARGS_IMPL(__VA_ARGS__,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
155 // clang-format on
156
157 #define _MAPPABLE_REFLECT_ARRAY(name) Reflect(visitor, value.name);
158
159 // Reflects the struct so it is serialized as an array instead of an object.
160 // This currently only supports writers.
161 #define MAKE_REFLECT_STRUCT_WRITER_AS_ARRAY(type, ...) \
162 inline void Reflect(Writer& visitor, type& value) \
163 { \
164 visitor.StartArray(NUM_VA_ARGS(__VA_ARGS__)); \
165 MACRO_MAP(_MAPPABLE_REFLECT_ARRAY, __VA_ARGS__) \
166 visitor.EndArray(); \
167 }
168
169 //// Elementary types
170
171 void Reflect(Reader& visitor, uint8_t& value);
172 void Reflect(Writer& visitor, uint8_t& value);
173
174 void Reflect(Reader& visitor, short& value);
175 void Reflect(Writer& visitor, short& value);
176
177 void Reflect(Reader& visitor, unsigned short& value);
178 void Reflect(Writer& visitor, unsigned short& value);
179
180 void Reflect(Reader& visitor, int& value);
181 void Reflect(Writer& visitor, int& value);
182
183 void Reflect(Reader& visitor, unsigned& value);
184 void Reflect(Writer& visitor, unsigned& value);
185
186 void Reflect(Reader& visitor, long& value);
187 void Reflect(Writer& visitor, long& value);
188
189 void Reflect(Reader& visitor, unsigned long& value);
190 void Reflect(Writer& visitor, unsigned long& value);
191
192 void Reflect(Reader& visitor, long long& value);
193 void Reflect(Writer& visitor, long long& value);
194
195 void Reflect(Reader& visitor, unsigned long long& value);
196 void Reflect(Writer& visitor, unsigned long long& value);
197
198 void Reflect(Reader& visitor, double& value);
199 void Reflect(Writer& visitor, double& value);
200
201 void Reflect(Reader& visitor, bool& value);
202 void Reflect(Writer& visitor, bool& value);
203
204 void Reflect(Reader& visitor, std::string& value);
205 void Reflect(Writer& visitor, std::string& value);
206
207 void Reflect(Reader& visitor, JsonNull& value);
208 void Reflect(Writer& visitor, JsonNull& value);
209
210 void Reflect(Reader& visitor, SerializeFormat& value);
211 void Reflect(Writer& visitor, SerializeFormat& value);
212
213 //// Type constructors
214 template<typename T>
215 void Reflect(Reader& visitor, optional<T>& value)
216 {
217 if (visitor.IsNull())
218 {
219 visitor.GetNull();
220 return;
221 }
222 T real_value;
223 Reflect(visitor, real_value);
224 value = std::move(real_value);
225 }
226 template<typename T>
227 void Reflect(Writer& visitor, optional<T>& value)
228 {
229 if (value)
230 {
231 Reflect(visitor, *value);
232 }
233 else
234 {
235 visitor.Null();
236 }
237 }
238
239 template<typename T>
240 void ReflectMember(Writer& visitor, char const* name, optional<T>& value)
241 {
242 // For TypeScript optional property key?: value in the spec,
243 // We omit both key and value if value is std::nullopt (null) for JsonWriter
244 // to reduce output. But keep it for other serialization formats.
245 if (value || visitor.Format() != SerializeFormat::Json)
246 {
247 visitor.Key(name);
248 Reflect(visitor, value);
249 }
250 }
251
252 template<typename T>
253 void ReflectMember(Writer& visitor, char const* name, T& value, optionals_mandatory_tag)
254 {
255 visitor.Key(name);
256 Reflect(visitor, value);
257 }
258 template<typename T>
259 void ReflectMember(Reader& visitor, char const* name, T& value, optionals_mandatory_tag)
260 {
261 Reflect(visitor, value);
262 }
263
264 template<class T>
265 void Reflect(Reader& visitor, std::map<std::string, T>& value)
266 {
267 visitor.IterMap(
268 [&](char const* name, Reader& entry)
269 {
270 T entry_value;
271 Reflect(entry, entry_value);
272 value[name] = (std::move(entry_value));
273 }
274 );
275 }
276 template<class _Ty>
277 void Reflect(Writer& visitor, std::map<std::string, _Ty>& value)
278 {
279 REFLECT_MEMBER_START();
280 for (auto& it : value)
281 {
282 visitor.Key(it.first.c_str());
283 Reflect(visitor, it.second);
284 }
285 REFLECT_MEMBER_END();
286 }
287
288 // std::vector
289 template<typename T>
290 void Reflect(Reader& visitor, std::vector<T>& values)
291 {
292 visitor.IterArray(
293 [&](Reader& entry)
294 {
295 T entry_value;
296 Reflect(entry, entry_value);
297 values.push_back(std::move(entry_value));
298 }
299 );
300 }
301
302 template<typename T>
303 void Reflect(Writer& visitor, std::vector<T>& values)
304 {
305 visitor.StartArray(values.size());
306 for (auto& value : values)
307 {
308 Reflect(visitor, value);
309 }
310 visitor.EndArray();
311 }
312
313 // ReflectMember
314
315 inline void DefaultReflectMemberStart(Writer& visitor)
316 {
317 visitor.StartObject();
318 }
319 inline void DefaultReflectMemberStart(Reader&)
320 {
321 }
322
323 template<typename T>
324 bool ReflectMemberStart(Reader&, T&)
325 {
326 return false;
327 }
328 template<typename T>
329 bool ReflectMemberStart(Writer& visitor, T&)
330 {
331 visitor.StartObject();
332 return true;
333 }
334
335 template<typename T>
336 void ReflectMemberEnd(Reader&, T&)
337 {
338 }
339 template<typename T>
340 void ReflectMemberEnd(Writer& visitor, T&)
341 {
342 visitor.EndObject();
343 }
344
345 template<typename T>
346 void ReflectMember(Reader& visitor, char const* name, T& value)
347 {
348 visitor.DoMember(name, [&](Reader& child) { Reflect(child, value); });
349 }
350 template<typename T>
351 void ReflectMember(Writer& visitor, char const* name, T& value)
352 {
353 visitor.Key(name);
354 Reflect(visitor, value);
355 }
356
357 template<class _Ty1, class _Ty2>
358 void Reflect(Writer& visitor, std::pair<optional<_Ty1>, optional<_Ty2>>& value)
359 {
360 if (value.first)
361 {
362 Reflect(visitor, value.first);
363 }
364 else
365 {
366 Reflect(visitor, value.second);
367 }
368 }
369 template<class _Ty2>
370 void Reflect(Reader& visitor, std::pair<optional<bool>, optional<_Ty2>>& value)
371 {
372 if (visitor.IsBool())
373 {
374 Reflect(visitor, value.first);
375 return;
376 }
377
378 Reflect(visitor, value.second);
379 }
380 template<class _Ty2>
381 void Reflect(Reader& visitor, std::pair<optional<std::string>, optional<_Ty2>>& value)
382 {
383 if (visitor.IsString())
384 {
385 Reflect(visitor, value.first);
386 return;
387 }
388
389 Reflect(visitor, value.second);
390 }
391
392 template<class _Ty1, class _Ty2>
393 void Reflect(Reader& visitor, std::pair<optional<_Ty1>, optional<_Ty2>>& value)
394 {
395 try
396 {
397 Reflect(visitor, value.second);
398 }
399 catch (...)
400 {
401 Reflect(visitor, value.first);
402 }
403 }