llvm/Support/JSON.h

62 // JSON strings are character sequences (not byte sequences like std::string).
81 std::string fixUTF8(llvm::StringRef S);
103   // (using std::pair forces extra copies).
105   explicit Object(std::initializer_list<KV> Properties);
116   std::pair<iterator, bool> insert(KV E);
118   std::pair<iterator, bool> try_emplace(const ObjectKey &K, Ts &&... Args) {
119     return M.try_emplace(K, std::forward<Ts>(Args)...);
122   std::pair<iterator, bool> try_emplace(ObjectKey &&K, Ts &&... Args) {
123     return M.try_emplace(std::move(K), std::forward<Ts>(Args)...);
139   llvm::Optional<std::nullptr_t> getNull(StringRef K) const;
155 /// It simulates std::vector<Value>.
157   std::vector<Value> V;
161   using iterator = std::vector<Value>::iterator;
162   using const_iterator = std::vector<Value>::const_iterator;
165   explicit Array(std::initializer_list<Value> Elements);
191   void push_back(Value &&E) { V.push_back(std::move(E)); }
193     V.emplace_back(std::forward<Args>(A)...);
199     return V.insert(P, std::move(E));
205     return V.emplace(P, std::forward<Args>(A)...);
218 ///   - strings: std::string, SmallString, formatv, StringRef, char*
261 ///   - std::string
297   Value(Value &&M) { moveFrom(std::move(M)); }
298   Value(std::initializer_list<Value> Elements);
300     create<json::Array>(std::move(Elements));
303   Value(const std::vector<Elt> &C) : Value(json::Array(C)) {}
305     create<json::Object>(std::move(Properties));
308   Value(const std::map<std::string, Elt> &C) : Value(json::Object(C)) {}
310   Value(std::string V) : Type(T_String) {
313       V = fixUTF8(std::move(V));
315     create<std::string>(std::move(V));
318       : Value(std::string(V.begin(), V.end())) {}
329   Value(std::nullptr_t) : Type(T_Null) {}
334       typename = typename std::enable_if<std::is_same<T, bool>::value>::type,
342       typename = typename std::enable_if<std::is_integral<T>::value>::type,
343       typename = typename std::enable_if<!std::is_same<T, bool>::value>::type>
350                 typename std::enable_if<std::is_floating_point<T>::value>::type,
357             typename = typename std::enable_if<std::is_same<
369     moveFrom(std::move(M));
395   llvm::Optional<std::nullptr_t> getAsNull() const {
418       if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
419                       D >= double(std::numeric_limits<int64_t>::min()) &&
420                       D <= double(std::numeric_limits<int64_t>::max())))
427       return llvm::StringRef(as<std::string>());
450   // (std::initializer_list<T> is a container of const T).
456     new (reinterpret_cast<T *>(Union.buffer)) T(std::forward<U>(V)...);
480                                       std::string, json::Array, json::Object>
495   ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
498       *Owned = fixUTF8(std::move(*Owned));
509       : ObjectKey(std::string(V.begin(), V.end())) {}
516       Owned.reset(new std::string(*C.Owned));
526   std::string str() const { return Data.str(); }
531   std::unique_ptr<std::string> Owned;
550 inline Object::Object(std::initializer_list<KV> Properties) {
554       R.first->getSecond().moveFrom(std::move(P.V));
557 inline std::pair<Object::iterator, bool> Object::insert(KV E) {
558   return try_emplace(std::move(E.K), std::move(E.V));
566 inline bool fromJSON(const Value &E, std::string &Out) {
609   Out = std::move(Result);
612 template <typename T> bool fromJSON(const Value &E, std::vector<T> &Out) {
624 bool fromJSON(const Value &E, std::map<std::string, T> &Out) {
698   std::error_code convertToErrorCode() const override {