Line data Source code
1 : //===--- JSON.h - JSON values, parsing and serialization -------*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===---------------------------------------------------------------------===//
9 : ///
10 : /// \file
11 : /// This file supports working with JSON data.
12 : ///
13 : /// It comprises:
14 : ///
15 : /// - classes which hold dynamically-typed parsed JSON structures
16 : /// These are value types that can be composed, inspected, and modified.
17 : /// See json::Value, and the related types json::Object and json::Array.
18 : ///
19 : /// - functions to parse JSON text into Values, and to serialize Values to text.
20 : /// See parse(), operator<<, and format_provider.
21 : ///
22 : /// - a convention and helpers for mapping between json::Value and user-defined
23 : /// types. See fromJSON(), ObjectMapper, and the class comment on Value.
24 : ///
25 : /// Typically, JSON data would be read from an external source, parsed into
26 : /// a Value, and then converted into some native data structure before doing
27 : /// real work on it. (And vice versa when writing).
28 : ///
29 : /// Other serialization mechanisms you may consider:
30 : ///
31 : /// - YAML is also text-based, and more human-readable than JSON. It's a more
32 : /// complex format and data model, and YAML parsers aren't ubiquitous.
33 : /// YAMLParser.h is a streaming parser suitable for parsing large documents
34 : /// (including JSON, as YAML is a superset). It can be awkward to use
35 : /// directly. YAML I/O (YAMLTraits.h) provides data mapping that is more
36 : /// declarative than the toJSON/fromJSON conventions here.
37 : ///
38 : /// - LLVM bitstream is a space- and CPU- efficient binary format. Typically it
39 : /// encodes LLVM IR ("bitcode"), but it can be a container for other data.
40 : /// Low-level reader/writer libraries are in Bitcode/Bitstream*.h
41 : ///
42 : //===---------------------------------------------------------------------===//
43 :
44 : #ifndef LLVM_SUPPORT_JSON_H
45 : #define LLVM_SUPPORT_JSON_H
46 :
47 : #include "llvm/ADT/DenseMap.h"
48 : #include "llvm/ADT/SmallVector.h"
49 : #include "llvm/ADT/StringRef.h"
50 : #include "llvm/Support/Error.h"
51 : #include "llvm/Support/FormatVariadic.h"
52 : #include "llvm/Support/raw_ostream.h"
53 : #include <map>
54 :
55 : namespace llvm {
56 : namespace json {
57 :
58 : // === String encodings ===
59 : //
60 : // JSON strings are character sequences (not byte sequences like std::string).
61 : // We need to know the encoding, and for simplicity only support UTF-8.
62 : //
63 : // - When parsing, invalid UTF-8 is a syntax error like any other
64 : //
65 : // - When creating Values from strings, callers must ensure they are UTF-8.
66 : // with asserts on, invalid UTF-8 will crash the program
67 : // with asserts off, we'll substitute the replacement character (U+FFFD)
68 : // Callers can use json::isUTF8() and json::fixUTF8() for validation.
69 : //
70 : // - When retrieving strings from Values (e.g. asString()), the result will
71 : // always be valid UTF-8.
72 :
73 : /// Returns true if \p S is valid UTF-8, which is required for use as JSON.
74 : /// If it returns false, \p Offset is set to a byte offset near the first error.
75 : bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
76 : /// Replaces invalid UTF-8 sequences in \p S with the replacement character
77 : /// (U+FFFD). The returned string is valid UTF-8.
78 : /// This is much slower than isUTF8, so test that first.
79 : std::string fixUTF8(llvm::StringRef S);
80 :
81 : class Array;
82 : class ObjectKey;
83 : class Value;
84 : template <typename T> Value toJSON(const llvm::Optional<T> &Opt);
85 :
86 : /// An Object is a JSON object, which maps strings to heterogenous JSON values.
87 : /// It simulates DenseMap<ObjectKey, Value>. ObjectKey is a maybe-owned string.
88 15994 : class Object {
89 : using Storage = DenseMap<ObjectKey, Value, llvm::DenseMapInfo<StringRef>>;
90 : Storage M;
91 :
92 : public:
93 : using key_type = ObjectKey;
94 : using mapped_type = Value;
95 : using value_type = Storage::value_type;
96 : using iterator = Storage::iterator;
97 : using const_iterator = Storage::const_iterator;
98 :
99 9 : explicit Object() = default;
100 : // KV is a trivial key-value struct for list-initialization.
101 : // (using std::pair forces extra copies).
102 : struct KV;
103 : explicit Object(std::initializer_list<KV> Properties);
104 :
105 : iterator begin() { return M.begin(); }
106 1302 : const_iterator begin() const { return M.begin(); }
107 : iterator end() { return M.end(); }
108 : const_iterator end() const { return M.end(); }
109 :
110 : bool empty() const { return M.empty(); }
111 : size_t size() const { return M.size(); }
112 :
113 : void clear() { M.clear(); }
114 : std::pair<iterator, bool> insert(KV E);
115 : template <typename... Ts>
116 : std::pair<iterator, bool> try_emplace(const ObjectKey &K, Ts &&... Args) {
117 3231 : return M.try_emplace(K, std::forward<Ts>(Args)...);
118 : }
119 : template <typename... Ts>
120 : std::pair<iterator, bool> try_emplace(ObjectKey &&K, Ts &&... Args) {
121 5911 : return M.try_emplace(std::move(K), std::forward<Ts>(Args)...);
122 : }
123 :
124 421 : iterator find(StringRef K) { return M.find_as(K); }
125 6059 : const_iterator find(StringRef K) const { return M.find_as(K); }
126 : // operator[] acts as if Value was default-constructible as null.
127 : Value &operator[](const ObjectKey &K);
128 : Value &operator[](ObjectKey &&K);
129 : // Look up a property, returning nullptr if it doesn't exist.
130 : Value *get(StringRef K);
131 : const Value *get(StringRef K) const;
132 : // Typed accessors return None/nullptr if
133 : // - the property doesn't exist
134 : // - or it has the wrong type
135 : llvm::Optional<std::nullptr_t> getNull(StringRef K) const;
136 : llvm::Optional<bool> getBoolean(StringRef K) const;
137 : llvm::Optional<double> getNumber(StringRef K) const;
138 : llvm::Optional<int64_t> getInteger(StringRef K) const;
139 : llvm::Optional<llvm::StringRef> getString(StringRef K) const;
140 : const json::Object *getObject(StringRef K) const;
141 : json::Object *getObject(StringRef K);
142 : const json::Array *getArray(StringRef K) const;
143 : json::Array *getArray(StringRef K);
144 : };
145 : bool operator==(const Object &LHS, const Object &RHS);
146 : inline bool operator!=(const Object &LHS, const Object &RHS) {
147 : return !(LHS == RHS);
148 : }
149 :
150 : /// An Array is a JSON array, which contains heterogeneous JSON values.
151 : /// It simulates std::vector<Value>.
152 1377 : class Array {
153 : std::vector<Value> V;
154 :
155 : public:
156 : using value_type = Value;
157 : using iterator = std::vector<Value>::iterator;
158 : using const_iterator = std::vector<Value>::const_iterator;
159 :
160 : explicit Array() = default;
161 : explicit Array(std::initializer_list<Value> Elements);
162 : template <typename Collection> explicit Array(const Collection &C) {
163 209 : for (const auto &V : C)
164 : emplace_back(V);
165 : }
166 :
167 1 : Value &operator[](size_t I) { return V[I]; }
168 1382 : const Value &operator[](size_t I) const { return V[I]; }
169 : Value &front() { return V.front(); }
170 : const Value &front() const { return V.front(); }
171 : Value &back() { return V.back(); }
172 : const Value &back() const { return V.back(); }
173 : Value *data() { return V.data(); }
174 : const Value *data() const { return V.data(); }
175 :
176 : iterator begin() { return V.begin(); }
177 0 : const_iterator begin() const { return V.begin(); }
178 : iterator end() { return V.end(); }
179 0 : const_iterator end() const { return V.end(); }
180 :
181 : bool empty() const { return V.empty(); }
182 1383 : size_t size() const { return V.size(); }
183 :
184 : void clear() { V.clear(); }
185 : void push_back(const Value &E) { V.push_back(E); }
186 223 : void push_back(Value &&E) { V.push_back(std::move(E)); }
187 : template <typename... Args> void emplace_back(Args &&... A) {
188 4049 : V.emplace_back(std::forward<Args>(A)...);
189 : }
190 : void pop_back() { V.pop_back(); }
191 : // FIXME: insert() takes const_iterator since C++11, old libstdc++ disagrees.
192 : iterator insert(iterator P, const Value &E) { return V.insert(P, E); }
193 : iterator insert(iterator P, Value &&E) {
194 : return V.insert(P, std::move(E));
195 : }
196 : template <typename It> iterator insert(iterator P, It A, It Z) {
197 : return V.insert(P, A, Z);
198 : }
199 : template <typename... Args> iterator emplace(const_iterator P, Args &&... A) {
200 : return V.emplace(P, std::forward<Args>(A)...);
201 : }
202 :
203 7 : friend bool operator==(const Array &L, const Array &R) { return L.V == R.V; }
204 : };
205 : inline bool operator!=(const Array &L, const Array &R) { return !(L == R); }
206 :
207 : /// A Value is an JSON value of unknown type.
208 : /// They can be copied, but should generally be moved.
209 : ///
210 : /// === Composing values ===
211 : ///
212 : /// You can implicitly construct Values from:
213 : /// - strings: std::string, SmallString, formatv, StringRef, char*
214 : /// (char*, and StringRef are references, not copies!)
215 : /// - numbers
216 : /// - booleans
217 : /// - null: nullptr
218 : /// - arrays: {"foo", 42.0, false}
219 : /// - serializable things: types with toJSON(const T&)->Value, found by ADL
220 : ///
221 : /// They can also be constructed from object/array helpers:
222 : /// - json::Object is a type like map<ObjectKey, Value>
223 : /// - json::Array is a type like vector<Value>
224 : /// These can be list-initialized, or used to build up collections in a loop.
225 : /// json::ary(Collection) converts all items in a collection to Values.
226 : ///
227 : /// === Inspecting values ===
228 : ///
229 : /// Each Value is one of the JSON kinds:
230 : /// null (nullptr_t)
231 : /// boolean (bool)
232 : /// number (double or int64)
233 : /// string (StringRef)
234 : /// array (json::Array)
235 : /// object (json::Object)
236 : ///
237 : /// The kind can be queried directly, or implicitly via the typed accessors:
238 : /// if (Optional<StringRef> S = E.getAsString()
239 : /// assert(E.kind() == Value::String);
240 : ///
241 : /// Array and Object also have typed indexing accessors for easy traversal:
242 : /// Expected<Value> E = parse(R"( {"options": {"font": "sans-serif"}} )");
243 : /// if (Object* O = E->getAsObject())
244 : /// if (Object* Opts = O->getObject("options"))
245 : /// if (Optional<StringRef> Font = Opts->getString("font"))
246 : /// assert(Opts->at("font").kind() == Value::String);
247 : ///
248 : /// === Converting JSON values to C++ types ===
249 : ///
250 : /// The convention is to have a deserializer function findable via ADL:
251 : /// fromJSON(const json::Value&, T&)->bool
252 : /// Deserializers are provided for:
253 : /// - bool
254 : /// - int and int64_t
255 : /// - double
256 : /// - std::string
257 : /// - vector<T>, where T is deserializable
258 : /// - map<string, T>, where T is deserializable
259 : /// - Optional<T>, where T is deserializable
260 : /// ObjectMapper can help writing fromJSON() functions for object types.
261 : ///
262 : /// For conversion in the other direction, the serializer function is:
263 : /// toJSON(const T&) -> json::Value
264 : /// If this exists, then it also allows constructing Value from T, and can
265 : /// be used to serialize vector<T>, map<string, T>, and Optional<T>.
266 : ///
267 : /// === Serialization ===
268 : ///
269 : /// Values can be serialized to JSON:
270 : /// 1) raw_ostream << Value // Basic formatting.
271 : /// 2) raw_ostream << formatv("{0}", Value) // Basic formatting.
272 : /// 3) raw_ostream << formatv("{0:2}", Value) // Pretty-print with indent 2.
273 : ///
274 : /// And parsed:
275 : /// Expected<Value> E = json::parse("[1, 2, null]");
276 : /// assert(E && E->kind() == Value::Array);
277 : class Value {
278 : public:
279 : enum Kind {
280 : Null,
281 : Boolean,
282 : /// Number values can store both int64s and doubles at full precision,
283 : /// depending on what they were constructed/parsed from.
284 : Number,
285 : String,
286 : Array,
287 : Object,
288 : };
289 :
290 : // It would be nice to have Value() be null. But that would make {} null too.
291 10634 : Value(const Value &M) { copyFrom(M); }
292 2234 : Value(Value &&M) { moveFrom(std::move(M)); }
293 : Value(std::initializer_list<Value> Elements);
294 1418 : Value(json::Array &&Elements) : Type(T_Array) {
295 : create<json::Array>(std::move(Elements));
296 : }
297 : template <typename Elt>
298 18 : Value(const std::vector<Elt> &C) : Value(json::Array(C)) {}
299 3148 : Value(json::Object &&Properties) : Type(T_Object) {
300 : create<json::Object>(std::move(Properties));
301 : }
302 : template <typename Elt>
303 : Value(const std::map<std::string, Elt> &C) : Value(json::Object(C)) {}
304 : // Strings: types with value semantics. Must be valid UTF-8.
305 4507 : Value(std::string V) : Type(T_String) {
306 4507 : if (LLVM_UNLIKELY(!isUTF8(V))) {
307 : assert(false && "Invalid UTF-8 in value used as JSON");
308 0 : V = fixUTF8(std::move(V));
309 : }
310 : create<std::string>(std::move(V));
311 4507 : }
312 1 : Value(const llvm::SmallVectorImpl<char> &V)
313 1 : : Value(std::string(V.begin(), V.end())){};
314 0 : Value(const llvm::formatv_object_base &V) : Value(V.str()){};
315 : // Strings: types with reference semantics. Must be valid UTF-8.
316 575 : Value(StringRef V) : Type(T_StringRef) {
317 : create<llvm::StringRef>(V);
318 575 : if (LLVM_UNLIKELY(!isUTF8(V))) {
319 : assert(false && "Invalid UTF-8 in value used as JSON");
320 2 : *this = Value(fixUTF8(V));
321 : }
322 575 : }
323 896 : Value(const char *V) : Value(StringRef(V)) {}
324 4405 : Value(std::nullptr_t) : Type(T_Null) {}
325 : // Boolean (disallow implicit conversions).
326 : // (The last template parameter is a dummy to keep templates distinct.)
327 : template <
328 : typename T,
329 : typename = typename std::enable_if<std::is_same<T, bool>::value>::type,
330 : bool = false>
331 792 : Value(T B) : Type(T_Boolean) {
332 : create<bool>(B);
333 : }
334 : // Integers (except boolean). Must be non-narrowing convertible to int64_t.
335 : template <
336 : typename T,
337 : typename = typename std::enable_if<std::is_integral<T>::value>::type,
338 : typename = typename std::enable_if<!std::is_same<T, bool>::value>::type>
339 3196 : Value(T I) : Type(T_Integer) {
340 1860 : create<int64_t>(int64_t{I});
341 : }
342 : // Floating point. Must be non-narrowing convertible to double.
343 : template <typename T,
344 : typename =
345 : typename std::enable_if<std::is_floating_point<T>::value>::type,
346 : double * = nullptr>
347 162 : Value(T D) : Type(T_Double) {
348 : create<double>(double{D});
349 : }
350 : // Serializable types: with a toJSON(const T&)->Value function, found by ADL.
351 : template <typename T,
352 : typename = typename std::enable_if<std::is_same<
353 : Value, decltype(toJSON(*(const T *)nullptr))>::value>,
354 : Value * = nullptr>
355 476 : Value(const T &V) : Value(toJSON(V)) {}
356 :
357 : Value &operator=(const Value &M) {
358 : destroy();
359 : copyFrom(M);
360 : return *this;
361 : }
362 : Value &operator=(Value &&M) {
363 7400 : destroy();
364 7840 : moveFrom(std::move(M));
365 : return *this;
366 : }
367 37184 : ~Value() { destroy(); }
368 :
369 0 : Kind kind() const {
370 0 : switch (Type) {
371 : case T_Null:
372 : return Null;
373 0 : case T_Boolean:
374 0 : return Boolean;
375 0 : case T_Double:
376 : case T_Integer:
377 0 : return Number;
378 0 : case T_String:
379 : case T_StringRef:
380 0 : return String;
381 0 : case T_Object:
382 0 : return Object;
383 0 : case T_Array:
384 0 : return Array;
385 : }
386 0 : llvm_unreachable("Unknown kind");
387 : }
388 :
389 : // Typed accessors return None/nullptr if the Value is not of this type.
390 0 : llvm::Optional<std::nullptr_t> getAsNull() const {
391 2 : if (LLVM_LIKELY(Type == T_Null))
392 : return nullptr;
393 : return llvm::None;
394 : }
395 : llvm::Optional<bool> getAsBoolean() const {
396 9 : if (LLVM_LIKELY(Type == T_Boolean))
397 : return as<bool>();
398 : return llvm::None;
399 : }
400 : llvm::Optional<double> getAsNumber() const {
401 32 : if (LLVM_LIKELY(Type == T_Double))
402 : return as<double>();
403 16 : if (LLVM_LIKELY(Type == T_Integer))
404 16 : return as<int64_t>();
405 : return llvm::None;
406 : }
407 : // Succeeds if the Value is a Number, and exactly representable as int64_t.
408 275 : llvm::Optional<int64_t> getAsInteger() const {
409 275 : if (LLVM_LIKELY(Type == T_Integer))
410 : return as<int64_t>();
411 5 : if (LLVM_LIKELY(Type == T_Double)) {
412 4 : double D = as<double>();
413 8 : if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
414 : D >= double(std::numeric_limits<int64_t>::min()) &&
415 4 : D <= double(std::numeric_limits<int64_t>::max())))
416 1 : return D;
417 : }
418 : return llvm::None;
419 : }
420 : llvm::Optional<llvm::StringRef> getAsString() const {
421 1958 : if (Type == T_String)
422 : return llvm::StringRef(as<std::string>());
423 14 : if (LLVM_LIKELY(Type == T_StringRef))
424 : return as<llvm::StringRef>();
425 : return llvm::None;
426 : }
427 : const json::Object *getAsObject() const {
428 1958 : return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
429 : }
430 : json::Object *getAsObject() {
431 2217 : return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
432 : }
433 : const json::Array *getAsArray() const {
434 1071 : return LLVM_LIKELY(Type == T_Array) ? &as<json::Array>() : nullptr;
435 : }
436 : json::Array *getAsArray() {
437 831 : return LLVM_LIKELY(Type == T_Array) ? &as<json::Array>() : nullptr;
438 : }
439 :
440 : /// Serializes this Value to JSON, writing it to the provided stream.
441 : /// The formatting is compact (no extra whitespace) and deterministic.
442 : /// For pretty-printing, use the formatv() format_provider below.
443 : friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Value &);
444 :
445 : private:
446 : void destroy();
447 : void copyFrom(const Value &M);
448 : // We allow moving from *const* Values, by marking all members as mutable!
449 : // This hack is needed to support initializer-list syntax efficiently.
450 : // (std::initializer_list<T> is a container of const T).
451 : void moveFrom(const Value &&M);
452 : friend class Array;
453 : friend class Object;
454 :
455 1109 : template <typename T, typename... U> void create(U &&... V) {
456 7430 : new (reinterpret_cast<T *>(Union.buffer)) T(std::forward<U>(V)...);
457 1109 : }
458 0 : template <typename T> T &as() const {
459 0 : // Using this two-step static_cast via void * instead of reinterpret_cast
460 0 : // silences a -Wstrict-aliasing false positive from GCC6 and earlier.
461 1508 : void *Storage = static_cast<void *>(Union.buffer);
462 0 : return *static_cast<T *>(Storage);
463 0 : }
464 0 :
465 0 : template <typename Indenter>
466 0 : void print(llvm::raw_ostream &, const Indenter &) const;
467 1109 : friend struct llvm::format_provider<llvm::json::Value>;
468 0 :
469 1109 : enum ValueType : char {
470 457 : T_Null,
471 0 : T_Boolean,
472 0 : T_Double,
473 13 : T_Integer,
474 : T_StringRef,
475 : T_String,
476 9597 : T_Object,
477 : T_Array,
478 : };
479 : // All members mutable, see moveFrom().
480 : mutable ValueType Type;
481 : mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, llvm::StringRef,
482 : std::string, json::Array, json::Object>
483 : Union;
484 : };
485 :
486 : bool operator==(const Value &, const Value &);
487 : inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
488 : llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Value &);
489 :
490 : /// ObjectKey is a used to capture keys in Object. Like Value but:
491 : /// - only strings are allowed
492 : /// - it's optimized for the string literal case (Owned == nullptr)
493 : /// Like Value, strings must be UTF-8. See isUTF8 documentation for details.
494 0 : class ObjectKey {
495 : public:
496 4 : ObjectKey(const char *S) : ObjectKey(StringRef(S)) {}
497 0 : ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
498 0 : if (LLVM_UNLIKELY(!isUTF8(*Owned))) {
499 : assert(false && "Invalid UTF-8 in value used as JSON");
500 0 : *Owned = fixUTF8(std::move(*Owned));
501 : }
502 1144 : Data = *Owned;
503 4118 : }
504 2 : ObjectKey(llvm::StringRef S) : Data(S) {
505 4842 : if (LLVM_UNLIKELY(!isUTF8(Data))) {
506 825 : assert(false && "Invalid UTF-8 in value used as JSON");
507 67 : *this = ObjectKey(fixUTF8(S));
508 1512 : }
509 320863 : }
510 37 : ObjectKey(const llvm::SmallVectorImpl<char> &V)
511 103 : : ObjectKey(std::string(V.begin(), V.end())) {}
512 5394 : ObjectKey(const llvm::formatv_object_base &V) : ObjectKey(V.str()) {}
513 16989 :
514 11663 : ObjectKey(const ObjectKey &C) { *this = C; }
515 37 : ObjectKey(ObjectKey &&C) : ObjectKey(static_cast<const ObjectKey &&>(C)) {}
516 3062 : ObjectKey &operator=(const ObjectKey &C) {
517 8389 : if (C.Owned) {
518 16989 : Owned.reset(new std::string(*C.Owned));
519 148716 : Data = *Owned;
520 148714 : } else {
521 3062 : Data = C.Data;
522 10 : }
523 128522 : return *this;
524 148714 : }
525 66787 : ObjectKey &operator=(ObjectKey &&) = default;
526 96099 :
527 10 : operator llvm::StringRef() const { return Data; }
528 15346 : std::string str() const { return Data.str(); }
529 458236 :
530 66788 : private:
531 221441 : // FIXME: this is unneccesarily large (3 pointers). Pointer + length + owned
532 288227 : // could be 2 pointers at most.
533 17857 : std::unique_ptr<std::string> Owned;
534 2512 : llvm::StringRef Data;
535 15346 : };
536 218928 :
537 : inline bool operator==(const ObjectKey &L, const ObjectKey &R) {
538 221440 : return llvm::StringRef(L) == llvm::StringRef(R);
539 0 : }
540 : inline bool operator!=(const ObjectKey &L, const ObjectKey &R) {
541 : return !(L == R);
542 0 : }
543 : inline bool operator<(const ObjectKey &L, const ObjectKey &R) {
544 : return StringRef(L) < StringRef(R);
545 : }
546 :
547 : struct Object::KV {
548 : ObjectKey K;
549 : Value V;
550 : };
551 :
552 0 : inline Object::Object(std::initializer_list<KV> Properties) {
553 0 : for (const auto &P : Properties) {
554 0 : auto R = try_emplace(P.K, nullptr);
555 0 : if (R.second)
556 0 : R.first->getSecond().moveFrom(std::move(P.V));
557 : }
558 2 : }
559 12 : inline std::pair<Object::iterator, bool> Object::insert(KV E) {
560 10 : return try_emplace(std::move(E.K), std::move(E.V));
561 1012 : }
562 3553 :
563 2531 : // Standard deserializers are provided for primitive types.
564 2762 : // See comments on Value.
565 5981 : inline bool fromJSON(const Value &E, std::string &Out) {
566 690 : if (auto S = E.getAsString()) {
567 1692 : Out = *S;
568 1380 : return true;
569 : }
570 229 : return false;
571 0 : }
572 0 : inline bool fromJSON(const Value &E, int &Out) {
573 0 : if (auto S = E.getAsInteger()) {
574 149 : Out = *S;
575 149 : return true;
576 296 : }
577 5 : return false;
578 5 : }
579 7 : inline bool fromJSON(const Value &E, int64_t &Out) {
580 : if (auto S = E.getAsInteger()) {
581 : Out = *S;
582 40 : return true;
583 37 : }
584 : return false;
585 1 : }
586 1 : inline bool fromJSON(const Value &E, double &Out) {
587 0 : if (auto S = E.getAsNumber()) {
588 : Out = *S;
589 : return true;
590 : }
591 : return false;
592 : }
593 : inline bool fromJSON(const Value &E, bool &Out) {
594 : if (auto S = E.getAsBoolean()) {
595 : Out = *S;
596 : return true;
597 : }
598 : return false;
599 : }
600 0 : template <typename T> bool fromJSON(const Value &E, llvm::Optional<T> &Out) {
601 0 : if (E.getAsNull()) {
602 : Out = llvm::None;
603 0 : return true;
604 0 : }
605 : T Result;
606 0 : if (!fromJSON(E, Result))
607 0 : return false;
608 : Out = std::move(Result);
609 140 : return true;
610 140 : }
611 0 : template <typename T> bool fromJSON(const Value &E, std::vector<T> &Out) {
612 1 : if (auto *A = E.getAsArray()) {
613 1 : Out.clear();
614 3 : Out.resize(A->size());
615 140 : for (size_t I = 0; I < A->size(); ++I)
616 : if (!fromJSON((*A)[I], Out[I]))
617 38 : return false;
618 52 : return true;
619 : }
620 2 : return false;
621 2 : }
622 0 : template <typename T>
623 1 : bool fromJSON(const Value &E, std::map<std::string, T> &Out) {
624 : if (auto *O = E.getAsObject()) {
625 : Out.clear();
626 3 : for (const auto &KV : *O)
627 4 : if (!fromJSON(KV.second, Out[llvm::StringRef(KV.first)]))
628 6 : return false;
629 2 : return true;
630 : }
631 9 : return false;
632 9 : }
633 0 :
634 0 : // Allow serialization of Optional<T> for supported T.
635 1 : template <typename T> Value toJSON(const llvm::Optional<T> &Opt) {
636 : return Opt ? Value(*Opt) : Value(nullptr);
637 9 : }
638 2 :
639 2 : /// Helper for mapping JSON objects onto protocol structs.
640 4 : ///
641 1 : /// Example:
642 4 : /// \code
643 2 : /// bool fromJSON(const Value &E, MyStruct &R) {
644 : /// ObjectMapper O(E);
645 0 : /// if (!O || !O.map("mandatory_field", R.MandatoryField))
646 : /// return false;
647 2 : /// O.map("optional_field", R.OptionalField);
648 4 : /// return true;
649 : /// }
650 : /// \endcode
651 : class ObjectMapper {
652 : public:
653 1 : ObjectMapper(const Value &E) : O(E.getAsObject()) {}
654 1 :
655 0 : /// True if the expression is an object.
656 0 : /// Must be checked before calling map().
657 : operator bool() { return O; }
658 :
659 1 : /// Maps a property to a field, if it exists.
660 : template <typename T> bool map(StringRef Prop, T &Out) {
661 : assert(*this && "Must check this is an object before calling map()");
662 1 : if (const Value *E = O->get(Prop))
663 0 : return fromJSON(*E, Out);
664 1 : return false;
665 1 : }
666 0 :
667 0 : /// Maps a property to a field, if it exists.
668 0 : /// (Optional requires special handling, because missing keys are OK).
669 1 : template <typename T> bool map(StringRef Prop, llvm::Optional<T> &Out) {
670 1 : assert(*this && "Must check this is an object before calling map()");
671 : if (const Value *E = O->get(Prop))
672 0 : return fromJSON(*E, Out);
673 1 : Out = llvm::None;
674 0 : return true;
675 38 : }
676 38 :
677 : private:
678 0 : const Object *O;
679 : };
680 0 :
681 38 : /// Parses the provided JSON source, or returns a ParseError.
682 : /// The returned Value is self-contained and owns its strings (they do not refer
683 38 : /// to the original source).
684 0 : llvm::Expected<Value> parse(llvm::StringRef JSON);
685 :
686 37 : class ParseError : public llvm::ErrorInfo<ParseError> {
687 37 : const char *Msg;
688 0 : unsigned Line, Column, Offset;
689 0 :
690 0 : public:
691 : static char ID;
692 37 : ParseError(const char *Msg, unsigned Line, unsigned Column, unsigned Offset)
693 0 : : Msg(Msg), Line(Line), Column(Column), Offset(Offset) {}
694 0 : void log(llvm::raw_ostream &OS) const override {
695 37 : OS << llvm::formatv("[{0}:{1}, byte={2}]: {3}", Line, Column, Offset, Msg);
696 0 : }
697 2 : std::error_code convertToErrorCode() const override {
698 2 : return llvm::inconvertibleErrorCode();
699 0 : }
700 0 : };
701 0 : } // namespace json
702 0 :
703 2 : /// Allow printing json::Value with formatv().
704 0 : /// The default style is basic/compact formatting, like operator<<.
705 0 : /// A format string like formatv("{0:2}", Value) pretty-prints with indent 2.
706 2 : template <> struct format_provider<llvm::json::Value> {
707 0 : static void format(const llvm::json::Value &, raw_ostream &, StringRef);
708 56 : };
709 56 : } // namespace llvm
710 18 :
711 18 : #endif
|
