1 /* json11 2 * 3 * json11 is a tiny JSON library for C++11, providing JSON parsing and serialization. 4 * 5 * The core object provided by the library is json11::Json. A Json object represents any JSON 6 * value: null, bool, number (int or double), string (std::string), array (std::vector), or 7 * object (std::map). 8 * 9 * Json objects act like values: they can be assigned, copied, moved, compared for equality or 10 * order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and 11 * Json::parse (static) to parse a std::string as a Json object. 12 * 13 * Internally, the various types of Json object are represented by the JsonValue class 14 * hierarchy. 15 * 16 * A note on numbers - JSON specifies the syntax of number formatting but not its semantics, 17 * so some JSON implementations distinguish between integers and floating-point numbers, while 18 * some don't. In json11, we choose the latter. Because some JSON implementations (namely 19 * Javascript itself) treat all numbers as the same type, distinguishing the two leads 20 * to JSON that will be *silently* changed by a round-trip through those implementations. 21 * Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also 22 * provides integer helpers. 23 * 24 * Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the 25 * range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64 26 * or long long to avoid the Y2038K problem; a double storing microseconds since some epoch 27 * will be exact for +/- 275 years.) 28 */ 29 30 /* Copyright (c) 2013 Dropbox, Inc. 31 * 32 * Permission is hereby granted, free of charge, to any person obtaining a copy 33 * of this software and associated documentation files (the "Software"), to deal 34 * in the Software without restriction, including without limitation the rights 35 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 36 * copies of the Software, and to permit persons to whom the Software is 37 * furnished to do so, subject to the following conditions: 38 * 39 * The above copyright notice and this permission notice shall be included in 40 * all copies or substantial portions of the Software. 41 * 42 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 43 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 44 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 45 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 46 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 47 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 48 * THE SOFTWARE. 49 */ 50 51 #pragma once 52 53 #include <string> 54 #include <vector> 55 #include <map> 56 #include <memory> 57 #include <initializer_list> 58 59 #ifdef _MSC_VER 60 #if _MSC_VER <= 1800 // VS 2013 61 #ifndef noexcept 62 #define noexcept throw() 63 #endif 64 65 #ifndef snprintf 66 #define snprintf _snprintf_s 67 #endif 68 #endif 69 #endif 70 71 namespace json11 { 72 73 enum JsonParse { 74 STANDARD, COMMENTS 75 }; 76 77 class JsonValue; 78 79 class Json final { 80 public: 81 // Types 82 enum Type { 83 NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT 84 }; 85 86 // Array and object typedefs 87 typedef std::vector<Json> array; 88 typedef std::map<std::string, Json> object; 89 90 // Constructors for the various types of JSON value. 91 Json() noexcept; // NUL 92 Json(std::nullptr_t) noexcept; // NUL 93 Json(double value); // NUMBER 94 Json(int value); // NUMBER 95 Json(bool value); // BOOL 96 Json(const std::string &value); // STRING 97 Json(std::string &&value); // STRING 98 Json(const char * value); // STRING 99 Json(const array &values); // ARRAY 100 Json(array &&values); // ARRAY 101 Json(const object &values); // OBJECT 102 Json(object &&values); // OBJECT 103 104 // Implicit constructor: anything with a to_json() function. 105 template <class T, class = decltype(&T::to_json)> Json(const T & t)106 Json(const T & t) : Json(t.to_json()) {} 107 108 // Implicit constructor: map-like objects (std::map, std::unordered_map, etc) 109 template <class M, typename std::enable_if< 110 std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value 111 && std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value, 112 int>::type = 0> Json(const M & m)113 Json(const M & m) : Json(object(m.begin(), m.end())) {} 114 115 // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc) 116 template <class V, typename std::enable_if< 117 std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value, 118 int>::type = 0> Json(const V & v)119 Json(const V & v) : Json(array(v.begin(), v.end())) {} 120 121 // This prevents Json(some_pointer) from accidentally producing a bool. Use 122 // Json(bool(some_pointer)) if that behavior is desired. 123 Json(void *) = delete; 124 125 // Accessors 126 Type type() const; 127 is_null() const128 bool is_null() const { return type() == NUL; } is_number() const129 bool is_number() const { return type() == NUMBER; } is_bool() const130 bool is_bool() const { return type() == BOOL; } is_string() const131 bool is_string() const { return type() == STRING; } is_array() const132 bool is_array() const { return type() == ARRAY; } is_object() const133 bool is_object() const { return type() == OBJECT; } 134 135 // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not 136 // distinguish between integer and non-integer numbers - number_value() and int_value() 137 // can both be applied to a NUMBER-typed object. 138 double number_value() const; 139 int int_value() const; 140 141 // Return the enclosed value if this is a boolean, false otherwise. 142 bool bool_value() const; 143 // Return the enclosed string if this is a string, "" otherwise. 144 const std::string &string_value() const; 145 // Return the enclosed std::vector if this is an array, or an empty vector otherwise. 146 const array &array_items() const; 147 // Return the enclosed std::map if this is an object, or an empty map otherwise. 148 const object &object_items() const; 149 150 // Return a reference to arr[i] if this is an array, Json() otherwise. 151 const Json & operator[](size_t i) const; 152 // Return a reference to obj[key] if this is an object, Json() otherwise. 153 const Json & operator[](const std::string &key) const; 154 155 // Serialize. 156 void dump(std::string &out) const; dump() const157 std::string dump() const { 158 std::string out; 159 dump(out); 160 return out; 161 } 162 163 // Parse. If parse fails, return Json() and assign an error message to err. 164 static Json parse(const std::string & in, 165 std::string & err, 166 JsonParse strategy = JsonParse::STANDARD); parse(const char * in,std::string & err,JsonParse strategy=JsonParse::STANDARD)167 static Json parse(const char * in, 168 std::string & err, 169 JsonParse strategy = JsonParse::STANDARD) { 170 if (in) { 171 return parse(std::string(in), err, strategy); 172 } else { 173 err = "null input"; 174 return nullptr; 175 } 176 } 177 // Parse multiple objects, concatenated or separated by whitespace 178 static std::vector<Json> parse_multi( 179 const std::string & in, 180 std::string::size_type & parser_stop_pos, 181 std::string & err, 182 JsonParse strategy = JsonParse::STANDARD); 183 parse_multi(const std::string & in,std::string & err,JsonParse strategy=JsonParse::STANDARD)184 static inline std::vector<Json> parse_multi( 185 const std::string & in, 186 std::string & err, 187 JsonParse strategy = JsonParse::STANDARD) { 188 std::string::size_type parser_stop_pos; 189 return parse_multi(in, parser_stop_pos, err, strategy); 190 } 191 192 bool operator== (const Json &rhs) const; 193 bool operator< (const Json &rhs) const; operator !=(const Json & rhs) const194 bool operator!= (const Json &rhs) const { return !(*this == rhs); } operator <=(const Json & rhs) const195 bool operator<= (const Json &rhs) const { return !(rhs < *this); } operator >(const Json & rhs) const196 bool operator> (const Json &rhs) const { return (rhs < *this); } operator >=(const Json & rhs) const197 bool operator>= (const Json &rhs) const { return !(*this < rhs); } 198 199 /* has_shape(types, err) 200 * 201 * Return true if this is a JSON object and, for each item in types, has a field of 202 * the given type. If not, return false and set err to a descriptive message. 203 */ 204 typedef std::initializer_list<std::pair<std::string, Type>> shape; 205 bool has_shape(const shape & types, std::string & err) const; 206 207 private: 208 std::shared_ptr<JsonValue> m_ptr; 209 }; 210 211 // Internal class hierarchy - JsonValue objects are not exposed to users of this API. 212 class JsonValue { 213 protected: 214 friend class Json; 215 friend class JsonInt; 216 friend class JsonDouble; 217 virtual Json::Type type() const = 0; 218 virtual bool equals(const JsonValue * other) const = 0; 219 virtual bool less(const JsonValue * other) const = 0; 220 virtual void dump(std::string &out) const = 0; 221 virtual double number_value() const; 222 virtual int int_value() const; 223 virtual bool bool_value() const; 224 virtual const std::string &string_value() const; 225 virtual const Json::array &array_items() const; 226 virtual const Json &operator[](size_t i) const; 227 virtual const Json::object &object_items() const; 228 virtual const Json &operator[](const std::string &key) const; ~JsonValue()229 virtual ~JsonValue() {} 230 }; 231 232 } // namespace json11 233