Skip to content

GitLab

Unverified Commit 5c201e48 authored by Guolin Ke's avatar Guolin Ke Committed by GitHub
Browse files

fix cpp lint in json11 (#2975) 



* indent and constructor

* fix more

* fix long
Co-authored-by: default avatarStrikerRUS <nekit94-12@hotmail.com>
parent 08be1e97
Hide whitespace changes
Inline Side-by-side
Showing with 739 additions and 742 deletions
include/LightGBM/utils/json11.h
View file @ 5c201e48
...@@ -21,200 +21,206 @@ ...@@ -21,200 +21,206 @@
/* json11 /* json11
* *
* json11 is a tiny JSON library for C++11, providing JSON parsing and serialization. * json11 is a tiny JSON library for C++11, providing JSON parsing and
* serialization.
* *
* The core object provided by the library is json11::Json. A Json object represents any JSON * The core object provided by the library is json11::Json. A Json object
* value: null, bool, number (int or double), string (std::string), array (std::vector), or * represents any JSON value: null, bool, number (int or double), string
* object (std::map). * (std::string), array (std::vector), or object (std::map).
* *
* Json objects act like values: they can be assigned, copied, moved, compared for equality or * Json objects act like values: they can be assigned, copied, moved, compared
* order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and * for equality or order, etc. There are also helper methods Json::dump, to
* Json::parse (static) to parse a std::string as a Json object. * serialize a Json to a string, and Json::parse (static) to parse a std::string
* as a Json object.
* *
* Internally, the various types of Json object are represented by the JsonValue class * Internally, the various types of Json object are represented by the JsonValue
* hierarchy. * class hierarchy.
* *
* A note on numbers - JSON specifies the syntax of number formatting but not its semantics, * A note on numbers - JSON specifies the syntax of number formatting but not
* so some JSON implementations distinguish between integers and floating-point numbers, while * its semantics, so some JSON implementations distinguish between integers and
* some don't. In json11, we choose the latter. Because some JSON implementations (namely * floating-point numbers, while some don't. In json11, we choose the latter.
* Javascript itself) treat all numbers as the same type, distinguishing the two leads * Because some JSON implementations (namely Javascript itself) treat all
* to JSON that will be *silently* changed by a round-trip through those implementations. * numbers as the same type, distinguishing the two leads to JSON that will be
* Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also * *silently* changed by a round-trip through those implementations. Dangerous!
* To avoid that risk, json11 stores all numbers as double internally, but also
* provides integer helpers. * provides integer helpers.
* *
* Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the * Fortunately, double-precision IEEE754 ('double') can precisely store any
* range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64 * integer in the range +/-2^53, which includes every 'int' on most systems.
* or long long to avoid the Y2038K problem; a double storing microseconds since some epoch * (Timestamps often use int64 or long long to avoid the Y2038K problem; a
* will be exact for +/- 275 years.) * double storing microseconds since some epoch will be exact for +/- 275
* years.)
*/ */
#pragma once #pragma once
#include <string>
#include <initializer_list> #include <initializer_list>
#include <map> #include <map>
#include <memory> #include <memory>
#include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace json11 { namespace json11 {
enum JsonParse { enum JsonParse { STANDARD, COMMENTS };
STANDARD, COMMENTS
};
class JsonValue; class JsonValue;
class Json final { class Json final {
public: public:
// Types // Types
enum Type { enum Type { NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT };
NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
}; // Array and object typedefs
typedef std::vector<Json> array;
// Array and object typedefs typedef std::map<std::string, Json> object;
typedef std::vector<Json> array;
typedef std::map<std::string, Json> object; // Constructors for the various types of JSON value.
Json() noexcept; // NUL
// Constructors for the various types of JSON value. explicit Json(std::nullptr_t) noexcept; // NUL
Json() noexcept; // NUL explicit Json(double value); // NUMBER
Json(std::nullptr_t) noexcept; // NUL explicit Json(int value); // NUMBER
Json(double value); // NUMBER explicit Json(bool value); // BOOL
Json(int value); // NUMBER explicit Json(const std::string &value); // STRING
Json(bool value); // BOOL explicit Json(std::string &&value); // STRING
Json(const std::string &value); // STRING explicit Json(const char *value); // STRING
Json(std::string &&value); // STRING explicit Json(const array &values); // ARRAY
Json(const char * value); // STRING explicit Json(array &&values); // ARRAY
Json(const array &values); // ARRAY explicit Json(const object &values); // OBJECT
Json(array &&values); // ARRAY explicit Json(object &&values); // OBJECT
Json(const object &values); // OBJECT
Json(object &&values); // OBJECT // Implicit constructor: anything with a to_json() function.
template <class T, class = decltype(&T::to_json)>
// Implicit constructor: anything with a to_json() function. explicit Json(const T &t) : Json(t.to_json()) {}
template <class T, class = decltype(&T::to_json)>
Json(const T & t) : Json(t.to_json()) {} // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
template <
// Implicit constructor: map-like objects (std::map, std::unordered_map, etc) class M,
template <class M, typename std::enable_if< typename std::enable_if<
std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value std::is_constructible<
&& std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value, std::string, decltype(std::declval<M>().begin()->first)>::value &&
int>::type = 0> std::is_constructible<
Json(const M & m) : Json(object(m.begin(), m.end())) {} Json, decltype(std::declval<M>().begin()->second)>::value,
int>::type = 0>
// Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc) explicit Json(const M &m) : Json(object(m.begin(), m.end())) {}
template <class V, typename std::enable_if<
std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value, // Implicit constructor: vector-like objects (std::list, std::vector,
int>::type = 0> // std::set, etc)
Json(const V & v) : Json(array(v.begin(), v.end())) {} template <class V, typename std::enable_if<
std::is_constructible<
// This prevents Json(some_pointer) from accidentally producing a bool. Use Json, decltype(*std::declval<V>().begin())>::value,
// Json(bool(some_pointer)) if that behavior is desired. int>::type = 0>
Json(void *) = delete; explicit Json(const V &v) : Json(array(v.begin(), v.end())) {}
// Accessors // This prevents Json(some_pointer) from accidentally producing a bool. Use
Type type() const; // Json(bool(some_pointer)) if that behavior is desired.
explicit Json(void *) = delete;
bool is_null() const { return type() == NUL; }
bool is_number() const { return type() == NUMBER; } // Accessors
bool is_bool() const { return type() == BOOL; } Type type() const;
bool is_string() const { return type() == STRING; }
bool is_array() const { return type() == ARRAY; } bool is_null() const { return type() == NUL; }
bool is_object() const { return type() == OBJECT; } bool is_number() const { return type() == NUMBER; }
bool is_bool() const { return type() == BOOL; }
// Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not bool is_string() const { return type() == STRING; }
// distinguish between integer and non-integer numbers - number_value() and int_value() bool is_array() const { return type() == ARRAY; }
// can both be applied to a NUMBER-typed object. bool is_object() const { return type() == OBJECT; }
double number_value() const;
int int_value() const; // Return the enclosed value if this is a number, 0 otherwise. Note that
// json11 does not distinguish between integer and non-integer numbers -
// Return the enclosed value if this is a boolean, false otherwise. // number_value() and int_value() can both be applied to a NUMBER-typed
bool bool_value() const; // object.
// Return the enclosed string if this is a string, "" otherwise. double number_value() const;
const std::string &string_value() const; int int_value() const;
// Return the enclosed std::vector if this is an array, or an empty vector otherwise.
const array &array_items() const; // Return the enclosed value if this is a boolean, false otherwise.
// Return the enclosed std::map if this is an object, or an empty map otherwise. bool bool_value() const;
const object &object_items() const; // Return the enclosed string if this is a string, "" otherwise.
const std::string &string_value() const;
// Return a reference to arr[i] if this is an array, Json() otherwise. // Return the enclosed std::vector if this is an array, or an empty vector
const Json & operator[](size_t i) const; // otherwise.
// Return a reference to obj[key] if this is an object, Json() otherwise. const array &array_items() const;
const Json & operator[](const std::string &key) const; // Return the enclosed std::map if this is an object, or an empty map
// otherwise.
// Serialize. const object &object_items() const;
void dump(std::string &out) const;
std::string dump() const { // Return a reference to arr[i] if this is an array, Json() otherwise.
std::string out; const Json &operator[](size_t i) const;
dump(out); // Return a reference to obj[key] if this is an object, Json() otherwise.
return out; const Json &operator[](const std::string &key) const;
// Serialize.
void dump(std::string *out) const;
std::string dump() const {
std::string out;
dump(&out);
return out;
}
// Parse. If parse fails, return Json() and assign an error message to err.
static Json parse(const std::string &in, std::string *err,
JsonParse strategy = JsonParse::STANDARD);
static Json parse(const char *in, std::string *err,
JsonParse strategy = JsonParse::STANDARD) {
if (in) {
return parse(std::string(in), err, strategy);
} else {
*err = "null input";
return Json(nullptr);
} }
}
// Parse. If parse fails, return Json() and assign an error message to err. // Parse multiple objects, concatenated or separated by whitespace
static Json parse(const std::string & in, static std::vector<Json> parse_multi(
std::string & err, const std::string &in, std::string::size_type *parser_stop_pos,
JsonParse strategy = JsonParse::STANDARD); std::string *err, JsonParse strategy = JsonParse::STANDARD);
static Json parse(const char * in,
std::string & err, static inline std::vector<Json> parse_multi(
JsonParse strategy = JsonParse::STANDARD) { const std::string &in, std::string *err,
if (in) { JsonParse strategy = JsonParse::STANDARD) {
return parse(std::string(in), err, strategy); std::string::size_type parser_stop_pos;
} else { return parse_multi(in, &parser_stop_pos, err, strategy);
err = "null input"; }
return nullptr;
} bool operator==(const Json &rhs) const;
} bool operator<(const Json &rhs) const;
// Parse multiple objects, concatenated or separated by whitespace bool operator!=(const Json &rhs) const { return !(*this == rhs); }
static std::vector<Json> parse_multi( bool operator<=(const Json &rhs) const { return !(rhs < *this); }
const std::string & in, bool operator>(const Json &rhs) const { return (rhs < *this); }
std::string::size_type & parser_stop_pos, bool operator>=(const Json &rhs) const { return !(*this < rhs); }
std::string & err,
JsonParse strategy = JsonParse::STANDARD); /* has_shape(types, err)
*
static inline std::vector<Json> parse_multi( * Return true if this is a JSON object and, for each item in types, has a
const std::string & in, * field of the given type. If not, return false and set err to a descriptive
std::string & err, * message.
JsonParse strategy = JsonParse::STANDARD) { */
std::string::size_type parser_stop_pos; typedef std::initializer_list<std::pair<std::string, Type>> shape;
return parse_multi(in, parser_stop_pos, err, strategy); bool has_shape(const shape &types, std::string *err) const;
}
bool operator== (const Json &rhs) const;
bool operator< (const Json &rhs) const;
bool operator!= (const Json &rhs) const { return !(*this == rhs); }
bool operator<= (const Json &rhs) const { return !(rhs < *this); }
bool operator> (const Json &rhs) const { return (rhs < *this); }
bool operator>= (const Json &rhs) const { return !(*this < rhs); }
/* has_shape(types, err)
*
* Return true if this is a JSON object and, for each item in types, has a field of
* the given type. If not, return false and set err to a descriptive message.
*/
typedef std::initializer_list<std::pair<std::string, Type>> shape;
bool has_shape(const shape & types, std::string & err) const;
private: private:
std::shared_ptr<JsonValue> m_ptr; std::shared_ptr<JsonValue> m_ptr;
}; };
// Internal class hierarchy - JsonValue objects are not exposed to users of this API. // Internal class hierarchy - JsonValue objects are not exposed to users of this
// API.
class JsonValue { class JsonValue {
protected: protected:
friend class Json; friend class Json;
friend class JsonInt; friend class JsonInt;
friend class JsonDouble; friend class JsonDouble;
virtual Json::Type type() const = 0; virtual Json::Type type() const = 0;
virtual bool equals(const JsonValue * other) const = 0; virtual bool equals(const JsonValue *other) const = 0;
virtual bool less(const JsonValue * other) const = 0; virtual bool less(const JsonValue *other) const = 0;
virtual void dump(std::string &out) const = 0; virtual void dump(std::string *out) const = 0;
virtual double number_value() const; virtual double number_value() const;
virtual int int_value() const; virtual int int_value() const;
virtual bool bool_value() const; virtual bool bool_value() const;
virtual const std::string &string_value() const; virtual const std::string &string_value() const;
virtual const Json::array &array_items() const; virtual const Json::array &array_items() const;
virtual const Json &operator[](size_t i) const; virtual const Json &operator[](size_t i) const;
virtual const Json::object &object_items() const; virtual const Json::object &object_items() const;
virtual const Json &operator[](const std::string &key) const; virtual const Json &operator[](const std::string &key) const;
virtual ~JsonValue() {} virtual ~JsonValue() {}
}; };
} // namespace json11 } // namespace json11
src/boosting/gbdt.cpp
View file @ 5c201e48
...@@ -64,7 +64,7 @@ void GBDT::Init(const Config* config, const Dataset* train_data, const Objective ...@@ -64,7 +64,7 @@ void GBDT::Init(const Config* config, const Dataset* train_data, const Objective
std::stringstream buffer; std::stringstream buffer;
buffer << forced_splits_file.rdbuf(); buffer << forced_splits_file.rdbuf();
std::string err; std::string err;
forced_splits_json_ = Json::parse(buffer.str(), err); forced_splits_json_ = Json::parse(buffer.str(), &err);
} }
objective_function_ = objective_function; objective_function_ = objective_function;
...@@ -725,7 +725,7 @@ void GBDT::ResetConfig(const Config* config) { ...@@ -725,7 +725,7 @@ void GBDT::ResetConfig(const Config* config) {
std::stringstream buffer; std::stringstream buffer;
buffer << forced_splits_file.rdbuf(); buffer << forced_splits_file.rdbuf();
std::string err; std::string err;
forced_splits_json_ = Json::parse(buffer.str(), err); forced_splits_json_ = Json::parse(buffer.str(), &err);
tree_learner_->SetForcedSplit(&forced_splits_json_); tree_learner_->SetForcedSplit(&forced_splits_json_);
} else { } else {
forced_splits_json_ = Json(); forced_splits_json_ = Json();
......
src/io/dataset_loader.cpp
View file @ 5c201e48
...@@ -1208,7 +1208,7 @@ std::vector<std::vector<double>> DatasetLoader::GetForcedBins(std::string forced ...@@ -1208,7 +1208,7 @@ std::vector<std::vector<double>> DatasetLoader::GetForcedBins(std::string forced
std::stringstream buffer; std::stringstream buffer;
buffer << forced_bins_stream.rdbuf(); buffer << forced_bins_stream.rdbuf();
std::string err; std::string err;
Json forced_bins_json = Json::parse(buffer.str(), err); Json forced_bins_json = Json::parse(buffer.str(), &err);
CHECK(forced_bins_json.is_array()); CHECK(forced_bins_json.is_array());
std::vector<Json> forced_bins_arr = forced_bins_json.array_items(); std::vector<Json> forced_bins_arr = forced_bins_json.array_items();
for (size_t i = 0; i < forced_bins_arr.size(); ++i) { for (size_t i = 0; i < forced_bins_arr.size(); ++i) {
......
src/io/json11.cpp
View file @ 5c201e48
...@@ -31,12 +31,12 @@ namespace json11 { ...@@ -31,12 +31,12 @@ namespace json11 {
static const int max_depth = 200; static const int max_depth = 200;
using std::string;
using std::vector;
using std::map;
using std::make_shared;
using std::initializer_list; using std::initializer_list;
using std::make_shared;
using std::map;
using std::move; using std::move;
using std::string;
using std::vector;
using LightGBM::Log; using LightGBM::Log;
...@@ -45,104 +45,98 @@ using LightGBM::Log; ...@@ -45,104 +45,98 @@ using LightGBM::Log;
* it may not be orderable. * it may not be orderable.
*/ */
struct NullStruct { struct NullStruct {
bool operator==(NullStruct) const { return true; } bool operator==(NullStruct) const { return true; }
bool operator<(NullStruct) const { return false; } bool operator<(NullStruct) const { return false; }
}; };
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Serialization * Serialization
*/ */
static void dump(NullStruct, string &out) { static void dump(NullStruct, string *out) { *out += "null"; }
out += "null";
}
static void dump(double value, string &out) {
if (std::isfinite(value)) {
char buf[32];
snprintf(buf, sizeof buf, "%.17g", value);
out += buf;
} else {
out += "null";
}
}
static void dump(int value, string &out) { static void dump(double value, string *out) {
if (std::isfinite(value)) {
char buf[32]; char buf[32];
snprintf(buf, sizeof buf, "%d", value); snprintf(buf, sizeof buf, "%.17g", value);
out += buf; *out += buf;
} else {
*out += "null";
}
} }
static void dump(bool value, string &out) { static void dump(int value, string *out) {
out += value ? "true" : "false"; char buf[32];
snprintf(buf, sizeof buf, "%d", value);
*out += buf;
} }
static void dump(const string &value, string &out) { static void dump(bool value, string *out) { *out += value ? "true" : "false"; }
out += '"';
for (size_t i = 0; i < value.length(); i++) { static void dump(const string &value, string *out) {
const char ch = value[i]; *out += '"';
if (ch == '\\') { for (size_t i = 0; i < value.length(); i++) {
out += "\\\\"; const char ch = value[i];
} else if (ch == '"') { if (ch == '\\') {
out += "\\\""; *out += "\\\\";
} else if (ch == '\b') { } else if (ch == '"') {
out += "\\b"; *out += "\\\"";
} else if (ch == '\f') { } else if (ch == '\b') {
out += "\\f"; *out += "\\b";
} else if (ch == '\n') { } else if (ch == '\f') {
out += "\\n"; *out += "\\f";
} else if (ch == '\r') { } else if (ch == '\n') {
out += "\\r"; *out += "\\n";
} else if (ch == '\t') { } else if (ch == '\r') {
out += "\\t"; *out += "\\r";
} else if (static_cast<uint8_t>(ch) <= 0x1f) { } else if (ch == '\t') {
char buf[8]; *out += "\\t";
snprintf(buf, sizeof buf, "\\u%04x", ch); } else if (static_cast<uint8_t>(ch) <= 0x1f) {
out += buf; char buf[8];
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80 snprintf(buf, sizeof buf, "\\u%04x", ch);
&& static_cast<uint8_t>(value[i+2]) == 0xa8) { *out += buf;
out += "\\u2028"; } else if (static_cast<uint8_t>(ch) == 0xe2 &&
i += 2; static_cast<uint8_t>(value[i + 1]) == 0x80 &&
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80 static_cast<uint8_t>(value[i + 2]) == 0xa8) {
&& static_cast<uint8_t>(value[i+2]) == 0xa9) { *out += "\\u2028";
out += "\\u2029"; i += 2;
i += 2; } else if (static_cast<uint8_t>(ch) == 0xe2 &&
} else { static_cast<uint8_t>(value[i + 1]) == 0x80 &&
out += ch; static_cast<uint8_t>(value[i + 2]) == 0xa9) {
} *out += "\\u2029";
i += 2;
} else {
*out += ch;
} }
out += '"'; }
*out += '"';
} }
static void dump(const Json::array &values, string &out) { static void dump(const Json::array &values, string *out) {
bool first = true; bool first = true;
out += "["; *out += "[";
for (const auto &value : values) { for (const auto &value : values) {
if (!first) if (!first) *out += ", ";
out += ", "; value.dump(out);
value.dump(out); first = false;
first = false; }
} *out += "]";
out += "]";
} }
static void dump(const Json::object &values, string &out) { static void dump(const Json::object &values, string *out) {
bool first = true; bool first = true;
out += "{"; *out += "{";
for (const auto &kv : values) { for (const auto &kv : values) {
if (!first) if (!first) *out += ", ";
out += ", "; dump(kv.first, out);
dump(kv.first, out); *out += ": ";
out += ": "; kv.second.dump(out);
kv.second.dump(out); first = false;
first = false; }
} *out += "}";
out += "}";
} }
void Json::dump(string &out) const { void Json::dump(string *out) const { m_ptr->dump(out); }
m_ptr->dump(out);
}
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Value wrappers * Value wrappers
...@@ -151,174 +145,195 @@ void Json::dump(string &out) const { ...@@ -151,174 +145,195 @@ void Json::dump(string &out) const {
template <Json::Type tag, typename T> template <Json::Type tag, typename T>
class Value : public JsonValue { class Value : public JsonValue {
protected: protected:
// Constructors // Constructors
explicit Value(const T &value) : m_value(value) {} explicit Value(const T &value) : m_value(value) {}
explicit Value(T &&value) : m_value(move(value)) {} explicit Value(T &&value) : m_value(move(value)) {}
// Get type tag // Get type tag
Json::Type type() const override { Json::Type type() const override { return tag; }
return tag;
} // Comparisons
bool equals(const JsonValue *other) const override {
// Comparisons return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
bool equals(const JsonValue * other) const override { }
return m_value == static_cast<const Value<tag, T> *>(other)->m_value; bool less(const JsonValue *other) const override {
} return m_value < (static_cast<const Value<tag, T> *>(other)->m_value);
bool less(const JsonValue * other) const override { }
return m_value < (static_cast<const Value<tag, T> *>(other)->m_value);
} const T m_value;
void dump(string *out) const override { json11::dump(m_value, out); }
const T m_value;
void dump(string &out) const override { json11::dump(m_value, out); }
}; };
class JsonDouble final : public Value<Json::NUMBER, double> { class JsonDouble final : public Value<Json::NUMBER, double> {
double number_value() const override { return m_value; } double number_value() const override { return m_value; }
int int_value() const override { return static_cast<int>(m_value); } int int_value() const override { return static_cast<int>(m_value); }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); } bool equals(const JsonValue *other) const override {
bool less(const JsonValue * other) const override { return m_value < other->number_value(); } return m_value == other->number_value();
}
bool less(const JsonValue *other) const override {
return m_value < other->number_value();
}
public: public:
explicit JsonDouble(double value) : Value(value) {} explicit JsonDouble(double value) : Value(value) {}
}; };
class JsonInt final : public Value<Json::NUMBER, int> { class JsonInt final : public Value<Json::NUMBER, int> {
double number_value() const override { return m_value; } double number_value() const override { return m_value; }
int int_value() const override { return m_value; } int int_value() const override { return m_value; }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); } bool equals(const JsonValue *other) const override {
bool less(const JsonValue * other) const override { return m_value < other->number_value(); } return m_value == other->number_value();
}
bool less(const JsonValue *other) const override {
return m_value < other->number_value();
}
public: public:
explicit JsonInt(int value) : Value(value) {} explicit JsonInt(int value) : Value(value) {}
}; };
class JsonBoolean final : public Value<Json::BOOL, bool> { class JsonBoolean final : public Value<Json::BOOL, bool> {
bool bool_value() const override { return m_value; } bool bool_value() const override { return m_value; }
public: public:
explicit JsonBoolean(bool value) : Value(value) {} explicit JsonBoolean(bool value) : Value(value) {}
}; };
class JsonString final : public Value<Json::STRING, string> { class JsonString final : public Value<Json::STRING, string> {
const string &string_value() const override { return m_value; } const string &string_value() const override { return m_value; }
public: public:
explicit JsonString(const string &value) : Value(value) {} explicit JsonString(const string &value) : Value(value) {}
explicit JsonString(string &&value) : Value(move(value)) {} explicit JsonString(string &&value) : Value(move(value)) {}
}; };
class JsonArray final : public Value<Json::ARRAY, Json::array> { class JsonArray final : public Value<Json::ARRAY, Json::array> {
const Json::array &array_items() const override { return m_value; } const Json::array &array_items() const override { return m_value; }
const Json & operator[](size_t i) const override; const Json &operator[](size_t i) const override;
public: public:
explicit JsonArray(const Json::array &value) : Value(value) {} explicit JsonArray(const Json::array &value) : Value(value) {}
explicit JsonArray(Json::array &&value) : Value(move(value)) {} explicit JsonArray(Json::array &&value) : Value(move(value)) {}
}; };
class JsonObject final : public Value<Json::OBJECT, Json::object> { class JsonObject final : public Value<Json::OBJECT, Json::object> {
const Json::object &object_items() const override { return m_value; } const Json::object &object_items() const override { return m_value; }
const Json & operator[](const string &key) const override; const Json &operator[](const string &key) const override;
public: public:
explicit JsonObject(const Json::object &value) : Value(value) {} explicit JsonObject(const Json::object &value) : Value(value) {}
explicit JsonObject(Json::object &&value) : Value(move(value)) {} explicit JsonObject(Json::object &&value) : Value(move(value)) {}
}; };
class JsonNull final : public Value<Json::NUL, NullStruct> { class JsonNull final : public Value<Json::NUL, NullStruct> {
public: public:
JsonNull() : Value({}) {} JsonNull() : Value({}) {}
}; };
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Static globals - static-init-safe * Static globals - static-init-safe
*/ */
struct Statics { struct Statics {
const std::shared_ptr<JsonValue> null = make_shared<JsonNull>(); const std::shared_ptr<JsonValue> null = make_shared<JsonNull>();
const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true); const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true);
const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false); const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false);
const string empty_string; const string empty_string;
const vector<Json> empty_vector; const vector<Json> empty_vector;
const map<string, Json> empty_map; const map<string, Json> empty_map;
Statics() {} Statics() {}
}; };
static const Statics & statics() { static const Statics &statics() {
static const Statics s {}; static const Statics s{};
return s; return s;
} }
static const Json & static_null() { static const Json &static_null() {
// This has to be separate, not in Statics, because Json() accesses statics().null. // This has to be separate, not in Statics, because Json() accesses
static const Json json_null; // statics().null.
return json_null; static const Json json_null;
return json_null;
} }
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Constructors * Constructors
*/ */
Json::Json() noexcept : m_ptr(statics().null) {} Json::Json() noexcept : m_ptr(statics().null) {}
Json::Json(std::nullptr_t) noexcept : m_ptr(statics().null) {} Json::Json(std::nullptr_t) noexcept : m_ptr(statics().null) {}
Json::Json(double value) : m_ptr(make_shared<JsonDouble>(value)) {} Json::Json(double value) : m_ptr(make_shared<JsonDouble>(value)) {}
Json::Json(int value) : m_ptr(make_shared<JsonInt>(value)) {} Json::Json(int value) : m_ptr(make_shared<JsonInt>(value)) {}
Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {} Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {}
Json::Json(const string &value) : m_ptr(make_shared<JsonString>(value)) {} Json::Json(const string &value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(string &&value) : m_ptr(make_shared<JsonString>(move(value))) {} Json::Json(string &&value) : m_ptr(make_shared<JsonString>(move(value))) {}
Json::Json(const char * value) : m_ptr(make_shared<JsonString>(value)) {} Json::Json(const char *value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {} Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {}
Json::Json(Json::array &&values) : m_ptr(make_shared<JsonArray>(move(values))) {} Json::Json(Json::array &&values)
Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {} : m_ptr(make_shared<JsonArray>(move(values))) {}
Json::Json(Json::object &&values) : m_ptr(make_shared<JsonObject>(move(values))) {} Json::Json(const Json::object &values)
: m_ptr(make_shared<JsonObject>(values)) {}
Json::Json(Json::object &&values)
: m_ptr(make_shared<JsonObject>(move(values))) {}
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Accessors * Accessors
*/ */
Json::Type Json::type() const { return m_ptr->type(); } Json::Type Json::type() const { return m_ptr->type(); }
double Json::number_value() const { return m_ptr->number_value(); } double Json::number_value() const { return m_ptr->number_value(); }
int Json::int_value() const { return m_ptr->int_value(); } int Json::int_value() const { return m_ptr->int_value(); }
bool Json::bool_value() const { return m_ptr->bool_value(); } bool Json::bool_value() const { return m_ptr->bool_value(); }
const string & Json::string_value() const { return m_ptr->string_value(); } const string &Json::string_value() const { return m_ptr->string_value(); }
const vector<Json> & Json::array_items() const { return m_ptr->array_items(); } const vector<Json> &Json::array_items() const { return m_ptr->array_items(); }
const map<string, Json> & Json::object_items() const { return m_ptr->object_items(); } const map<string, Json> &Json::object_items() const {
const Json & Json::operator[] (size_t i) const { return (*m_ptr)[i]; } return m_ptr->object_items();
const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key]; } }
const Json &Json::operator[](size_t i) const { return (*m_ptr)[i]; }
double JsonValue::number_value() const { return 0; } const Json &Json::operator[](const string &key) const { return (*m_ptr)[key]; }
int JsonValue::int_value() const { return 0; }
bool JsonValue::bool_value() const { return false; } double JsonValue::number_value() const { return 0; }
const string & JsonValue::string_value() const { return statics().empty_string; } int JsonValue::int_value() const { return 0; }
const vector<Json> & JsonValue::array_items() const { return statics().empty_vector; } bool JsonValue::bool_value() const { return false; }
const map<string, Json> & JsonValue::object_items() const { return statics().empty_map; } const string &JsonValue::string_value() const { return statics().empty_string; }
const Json & JsonValue::operator[] (size_t) const { return static_null(); } const vector<Json> &JsonValue::array_items() const {
const Json & JsonValue::operator[] (const string &) const { return static_null(); } return statics().empty_vector;
}
const Json & JsonObject::operator[] (const string &key) const { const map<string, Json> &JsonValue::object_items() const {
auto iter = m_value.find(key); return statics().empty_map;
return (iter == m_value.end()) ? static_null() : iter->second; }
const Json &JsonValue::operator[](size_t) const { return static_null(); }
const Json &JsonValue::operator[](const string &) const {
return static_null();
}
const Json &JsonObject::operator[](const string &key) const {
auto iter = m_value.find(key);
return (iter == m_value.end()) ? static_null() : iter->second;
} }
const Json & JsonArray::operator[] (size_t i) const { const Json &JsonArray::operator[](size_t i) const {
if (i >= m_value.size()) if (i >= m_value.size())
return static_null(); return static_null();
else else
return m_value[i]; return m_value[i];
} }
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Comparison * Comparison
*/ */
bool Json::operator== (const Json &other) const { bool Json::operator==(const Json &other) const {
if (m_ptr == other.m_ptr) if (m_ptr == other.m_ptr) return true;
return true; if (m_ptr->type() != other.m_ptr->type()) return false;
if (m_ptr->type() != other.m_ptr->type())
return false;
return m_ptr->equals(other.m_ptr.get()); return m_ptr->equals(other.m_ptr.get());
} }
bool Json::operator< (const Json &other) const { bool Json::operator<(const Json &other) const {
if (m_ptr == other.m_ptr) if (m_ptr == other.m_ptr) return false;
return false; if (m_ptr->type() != other.m_ptr->type())
if (m_ptr->type() != other.m_ptr->type()) return m_ptr->type() < other.m_ptr->type();
return m_ptr->type() < other.m_ptr->type();
return m_ptr->less(other.m_ptr.get()); return m_ptr->less(other.m_ptr.get());
} }
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
...@@ -330,17 +345,18 @@ bool Json::operator< (const Json &other) const { ...@@ -330,17 +345,18 @@ bool Json::operator< (const Json &other) const {
* Format char c suitable for printing in an error message. * Format char c suitable for printing in an error message.
*/ */
static inline string esc(char c) { static inline string esc(char c) {
char buf[12]; char buf[12];
if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) { if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) {
snprintf(buf, sizeof buf, "'%c' (%d)", c, c); snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
} else { } else {
snprintf(buf, sizeof buf, "(%d)", c); snprintf(buf, sizeof buf, "(%d)", c);
} }
return string(buf); return string(buf);
} }
static inline bool in_range(long x, long lower, long upper) { template <typename T>
return (x >= lower && x <= upper); static inline bool in_range(T x, T lower, T upper) {
return (x >= lower && x <= upper);
} }
namespace { namespace {
...@@ -349,442 +365,417 @@ namespace { ...@@ -349,442 +365,417 @@ namespace {
* Object that tracks all state of an in-progress parse. * Object that tracks all state of an in-progress parse.
*/ */
struct JsonParser final { struct JsonParser final {
/* State /* State
*/ */
const char* str; const char *str;
const size_t str_len; const size_t str_len;
size_t i; size_t i;
string &err; string *err;
bool failed; bool failed;
const JsonParse strategy; const JsonParse strategy;
/* fail(msg, err_ret = Json()) /* fail(msg, err_ret = Json())
* *
* Mark this parse as failed. * Mark this parse as failed.
*/ */
Json fail(string &&msg) { Json fail(string &&msg) { return fail(move(msg), Json()); }
return fail(move(msg), Json());
} template <typename T>
T fail(string &&msg, const T err_ret) {
template <typename T> if (!failed) *err = std::move(msg);
T fail(string &&msg, const T err_ret) { failed = true;
if (!failed) return err_ret;
err = std::move(msg); }
failed = true;
return err_ret; /* consume_whitespace()
} *
* Advance until the current character is non-whitespace.
/* consume_whitespace() */
* void consume_whitespace() {
* Advance until the current character is non-whitespace. while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t')
*/ i++;
void consume_whitespace() { }
while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t')
i++; /* consume_comment()
} *
* Advance comments (c-style inline and multiline).
/* consume_comment() */
* bool consume_comment() {
* Advance comments (c-style inline and multiline). bool comment_found = false;
*/ if (str[i] == '/') {
bool consume_comment() { i++;
bool comment_found = false; if (i == str_len)
if (str[i] == '/') { return fail("Unexpected end of input after start of comment", false);
if (str[i] == '/') { // inline comment
i++; i++;
if (i == str_len) // advance until next line, or end of input
return fail("Unexpected end of input after start of comment", false); while (i < str_len && str[i] != '\n') {
if (str[i] == '/') { // inline comment
i++; i++;
// advance until next line, or end of input }
while (i < str_len && str[i] != '\n') { comment_found = true;
i++; } else if (str[i] == '*') { // multiline comment
} i++;
comment_found = true; if (i > str_len - 2)
} else if (str[i] == '*') { // multiline comment return fail("Unexpected end of input inside multi-line comment",
false);
// advance until closing tokens
while (!(str[i] == '*' && str[i + 1] == '/')) {
i++; i++;
if (i > str_len - 2) if (i > str_len - 2)
return fail("Unexpected end of input inside multi-line comment", false); return fail("Unexpected end of input inside multi-line comment",
// advance until closing tokens false);
while (!(str[i] == '*' && str[i+1] == '/')) {
i++;
if (i > str_len - 2)
return fail("Unexpected end of input inside multi-line comment", false);
}
i += 2;
comment_found = true;
} else {
return fail("Malformed comment", false);
} }
i += 2;
comment_found = true;
} else {
return fail("Malformed comment", false);
} }
return comment_found;
} }
return comment_found;
}
/* consume_garbage()
*
* Advance until the current character is non-whitespace and non-comment.
*/
void consume_garbage() {
consume_whitespace();
if (strategy == JsonParse::COMMENTS) {
bool comment_found = false;
do {
comment_found = consume_comment();
if (failed) return;
consume_whitespace();
} while (comment_found);
}
}
/* get_next_token()
*
* Return the next non-whitespace character. If the end of the input is
* reached, flag an error and return 0.
*/
char get_next_token() {
consume_garbage();
if (failed) return char{0};
if (i == str_len) return fail("Unexpected end of input", char{0});
return str[i++];
}
/* encode_utf8(pt, out)
*
* Encode pt as UTF-8 and add it to out.
*/
void encode_utf8(int64_t pt, string* out) {
if (pt < 0) return;
if (pt < 0x80) {
*out += static_cast<char>(pt);
} else if (pt < 0x800) {
*out += static_cast<char>((pt >> 6) | 0xC0);
*out += static_cast<char>((pt & 0x3F) | 0x80);
} else if (pt < 0x10000) {
*out += static_cast<char>((pt >> 12) | 0xE0);
*out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
*out += static_cast<char>((pt & 0x3F) | 0x80);
} else {
*out += static_cast<char>((pt >> 18) | 0xF0);
*out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
*out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
*out += static_cast<char>((pt & 0x3F) | 0x80);
}
}
/* parse_string()
*
* Parse a string, starting at the current position.
*/
string parse_string() {
string out;
int64_t last_escaped_codepoint = -1;
while (true) {
if (i == str_len) return fail("Unexpected end of input in string", "");
char ch = str[i++];
if (ch == '"') {
encode_utf8(last_escaped_codepoint, &out);
return out;
}
/* consume_garbage() if (in_range<int64_t>(ch, 0, 0x1f))
* return fail("Unescaped " + esc(ch) + " in string", "");
* Advance until the current character is non-whitespace and non-comment.
*/ // The usual case: non-escaped characters
void consume_garbage() { if (ch != '\\') {
consume_whitespace(); encode_utf8(last_escaped_codepoint, &out);
if (strategy == JsonParse::COMMENTS) { last_escaped_codepoint = -1;
bool comment_found = false; out += ch;
do { continue;
comment_found = consume_comment();
if (failed) return;
consume_whitespace();
} while (comment_found);
} }
}
/* get_next_token() // Handle escapes
* if (i == str_len) return fail("Unexpected end of input in string", "");
* Return the next non-whitespace character. If the end of the input is reached,
* flag an error and return 0.
*/
char get_next_token() {
consume_garbage();
if (failed) return char{0};
if (i == str_len)
return fail("Unexpected end of input", char{0});
return str[i++];
}
/* encode_utf8(pt, out) ch = str[i++];
*
* Encode pt as UTF-8 and add it to out.
*/
void encode_utf8(long pt, string & out) {
if (pt < 0)
return;
if (pt < 0x80) {
out += static_cast<char>(pt);
} else if (pt < 0x800) {
out += static_cast<char>((pt >> 6) | 0xC0);
out += static_cast<char>((pt & 0x3F) | 0x80);
} else if (pt < 0x10000) {
out += static_cast<char>((pt >> 12) | 0xE0);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
} else {
out += static_cast<char>((pt >> 18) | 0xF0);
out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
}
}
/* parse_string() if (ch == 'u') {
* // Extract 4-byte escape sequence
* Parse a string, starting at the current position. string esc = string(str + i, 4);
*/ // Explicitly check length of the substring. The following loop
string parse_string() { // relies on std::string returning the terminating NUL when
string out; // accessing str[length]. Checking here reduces brittleness.
long last_escaped_codepoint = -1; if (esc.length() < 4) {
while (true) { return fail("Bad \\u escape: " + esc, "");
if (i == str_len) }
return fail("Unexpected end of input in string", ""); for (size_t j = 0; j < 4; j++) {
if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F') &&
char ch = str[i++]; !in_range(esc[j], '0', '9'))
return fail("Bad \\u escape: " + esc, "");
if (ch == '"') {
encode_utf8(last_escaped_codepoint, out);
return out;
}
if (in_range(ch, 0, 0x1f))
return fail("Unescaped " + esc(ch) + " in string", "");
// The usual case: non-escaped characters
if (ch != '\\') {
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = -1;
out += ch;
continue;
}
// Handle escapes
if (i == str_len)
return fail("Unexpected end of input in string", "");
ch = str[i++];
if (ch == 'u') {
// Extract 4-byte escape sequence
string esc = string(str + i, 4);
// Explicitly check length of the substring. The following loop
// relies on std::string returning the terminating NUL when
// accessing str[length]. Checking here reduces brittleness.
if (esc.length() < 4) {
return fail("Bad \\u escape: " + esc, "");
}
for (size_t j = 0; j < 4; j++) {
if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F')
&& !in_range(esc[j], '0', '9'))
return fail("Bad \\u escape: " + esc, "");
}
long codepoint = strtol(esc.data(), nullptr, 16);
// JSON specifies that characters outside the BMP shall be encoded as a pair
// of 4-hex-digit \u escapes encoding their surrogate pair components. Check
// whether we're in the middle of such a beast: the previous codepoint was an
// escaped lead (high) surrogate, and this is a trail (low) surrogate.
if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
&& in_range(codepoint, 0xDC00, 0xDFFF)) {
// Reassemble the two surrogate pairs into one astral-plane character, per
// the UTF-16 algorithm.
encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
| (codepoint - 0xDC00)) + 0x10000, out);
last_escaped_codepoint = -1;
} else {
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = codepoint;
}
i += 4;
continue;
}
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = -1;
if (ch == 'b') {
out += '\b';
} else if (ch == 'f') {
out += '\f';
} else if (ch == 'n') {
out += '\n';
} else if (ch == 'r') {
out += '\r';
} else if (ch == 't') {
out += '\t';
} else if (ch == '"' || ch == '\\' || ch == '/') {
out += ch;
} else {
return fail("Invalid escape character " + esc(ch), "");
}
} }
}
/* parse_number() int64_t codepoint =
* static_cast<int64_t>(strtol(esc.data(), nullptr, 16));
* Parse a double.
*/ // JSON specifies that characters outside the BMP shall be encoded as a
Json parse_number() { // pair of 4-hex-digit \u escapes encoding their surrogate pair
size_t start_pos = i; // components. Check whether we're in the middle of such a beast: the
// previous codepoint was an escaped lead (high) surrogate, and this is
if (str[i] == '-') // a trail (low) surrogate.
i++; if (in_range<int64_t>(last_escaped_codepoint, 0xD800, 0xDBFF) &&
in_range<int64_t>(codepoint, 0xDC00, 0xDFFF)) {
// Integer part // Reassemble the two surrogate pairs into one astral-plane character,
if (str[i] == '0') { // per the UTF-16 algorithm.
i++; encode_utf8((((last_escaped_codepoint - 0xD800) << 10) |
if (in_range(str[i], '0', '9')) (codepoint - 0xDC00)) +
return fail("Leading 0s not permitted in numbers"); 0x10000,
} else if (in_range(str[i], '1', '9')) { &out);
i++; last_escaped_codepoint = -1;
while (in_range(str[i], '0', '9'))
i++;
} else { } else {
return fail("Invalid " + esc(str[i]) + " in number"); encode_utf8(last_escaped_codepoint, &out);
last_escaped_codepoint = codepoint;
} }
if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' i += 4;
&& (i - start_pos) <= static_cast<size_t>(std::numeric_limits<int>::digits10)) { continue;
return std::atoi(str + start_pos); }
}
// Decimal part encode_utf8(last_escaped_codepoint, &out);
if (str[i] == '.') { last_escaped_codepoint = -1;
i++;
if (!in_range(str[i], '0', '9')) if (ch == 'b') {
return fail("At least one digit required in fractional part"); out += '\b';
} else if (ch == 'f') {
out += '\f';
} else if (ch == 'n') {
out += '\n';
} else if (ch == 'r') {
out += '\r';
} else if (ch == 't') {
out += '\t';
} else if (ch == '"' || ch == '\\' || ch == '/') {
out += ch;
} else {
return fail("Invalid escape character " + esc(ch), "");
}
}
}
/* parse_number()
*
* Parse a double.
*/
Json parse_number() {
size_t start_pos = i;
if (str[i] == '-') i++;
// Integer part
if (str[i] == '0') {
i++;
if (in_range(str[i], '0', '9'))
return fail("Leading 0s not permitted in numbers");
} else if (in_range(str[i], '1', '9')) {
i++;
while (in_range(str[i], '0', '9')) i++;
} else {
return fail("Invalid " + esc(str[i]) + " in number");
}
while (in_range(str[i], '0', '9')) if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' &&
i++; (i - start_pos) <=
} static_cast<size_t>(std::numeric_limits<int>::digits10)) {
return Json(std::atoi(str + start_pos));
}
// Decimal part
if (str[i] == '.') {
i++;
if (!in_range(str[i], '0', '9'))
return fail("At least one digit required in fractional part");
// Exponent part while (in_range(str[i], '0', '9')) i++;
if (str[i] == 'e' || str[i] == 'E') { }
i++;
if (str[i] == '+' || str[i] == '-') // Exponent part
i++; if (str[i] == 'e' || str[i] == 'E') {
i++;
if (!in_range(str[i], '0', '9')) if (str[i] == '+' || str[i] == '-') i++;
return fail("At least one digit required in exponent");
while (in_range(str[i], '0', '9')) if (!in_range(str[i], '0', '9'))
i++; return fail("At least one digit required in exponent");
}
return std::strtod(str + start_pos, nullptr); while (in_range(str[i], '0', '9')) i++;
} }
/* expect(str, res) return Json(std::strtod(str + start_pos, nullptr));
* }
* Expect that 'str' starts at the character that was just read. If it does, advance
* the input and return res. If not, flag an error. /* expect(str, res)
*/ *
Json expect(const string &expected, Json res) { * Expect that 'str' starts at the character that was just read. If it does,
CHECK_NE(i, 0) * advance the input and return res. If not, flag an error.
i--; */
auto substr = string(str + i, expected.length()); Json expect(const string &expected, Json res) {
if (substr == expected) { CHECK_NE(i, 0)
i += expected.length(); i--;
return res; auto substr = string(str + i, expected.length());
} else { if (substr == expected) {
return fail("Parse error: expected " + expected + ", got " + substr); i += expected.length();
} return res;
} else {
return fail("Parse error: expected " + expected + ", got " + substr);
}
}
/* parse_json()
*
* Parse a JSON object.
*/
Json parse_json(int depth) {
if (depth > max_depth) {
return fail("Exceeded maximum nesting depth");
} }
/* parse_json() char ch = get_next_token();
* if (failed) return Json();
* Parse a JSON object.
*/
Json parse_json(int depth) {
if (depth > max_depth) {
return fail("Exceeded maximum nesting depth");
}
char ch = get_next_token(); if (ch == '-' || (ch >= '0' && ch <= '9')) {
if (failed) i--;
return Json(); return parse_number();
}
if (ch == '-' || (ch >= '0' && ch <= '9')) { if (ch == 't') return expect("true", Json(true));
i--;
return parse_number();
}
if (ch == 't') if (ch == 'f') return expect("false", Json(false));
return expect("true", true);
if (ch == 'f') if (ch == 'n') return expect("null", Json());
return expect("false", false);
if (ch == 'n') if (ch == '"') return Json(parse_string());
return expect("null", Json());
if (ch == '"') if (ch == '{') {
return parse_string(); map<string, Json> data;
ch = get_next_token();
if (ch == '}') return Json(data);
if (ch == '{') { while (1) {
map<string, Json> data; if (ch != '"') return fail("Expected '\"' in object, got " + esc(ch));
ch = get_next_token();
if (ch == '}')
return data;
while (1) { string key = parse_string();
if (ch != '"') if (failed) return Json();
return fail("Expected '\"' in object, got " + esc(ch));
string key = parse_string(); ch = get_next_token();
if (failed) if (ch != ':') return fail("Expected ':' in object, got " + esc(ch));
return Json();
ch = get_next_token(); data[std::move(key)] = parse_json(depth + 1);
if (ch != ':') if (failed) return Json();
return fail("Expected ':' in object, got " + esc(ch));
data[std::move(key)] = parse_json(depth + 1); ch = get_next_token();
if (failed) if (ch == '}') break;
return Json(); if (ch != ',') return fail("Expected ',' in object, got " + esc(ch));
ch = get_next_token(); ch = get_next_token();
if (ch == '}') }
break; return Json(data);
if (ch != ',') }
return fail("Expected ',' in object, got " + esc(ch));
ch = get_next_token(); if (ch == '[') {
} vector<Json> data;
return data; ch = get_next_token();
} if (ch == ']') return Json(data);
if (ch == '[') { while (1) {
vector<Json> data; i--;
ch = get_next_token(); data.push_back(parse_json(depth + 1));
if (ch == ']') if (failed) return Json();
return data;
while (1) {
i--;
data.push_back(parse_json(depth + 1));
if (failed)
return Json();
ch = get_next_token();
if (ch == ']')
break;
if (ch != ',')
return fail("Expected ',' in list, got " + esc(ch));
ch = get_next_token();
(void)ch;
}
return data;
}
return fail("Expected value, got " + esc(ch)); ch = get_next_token();
if (ch == ']') break;
if (ch != ',') return fail("Expected ',' in list, got " + esc(ch));
ch = get_next_token();
(void)ch;
}
return Json(data);
} }
return fail("Expected value, got " + esc(ch));
}
}; };
} // namespace } // namespace
Json Json::parse(const string &in, string &err, JsonParse strategy) { Json Json::parse(const string &in, string *err, JsonParse strategy) {
JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy}; JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
Json result = parser.parse_json(0); Json result = parser.parse_json(0);
// Check for any trailing garbage // Check for any trailing garbage
parser.consume_garbage(); parser.consume_garbage();
if (parser.failed) if (parser.failed) return Json();
return Json(); if (parser.i != in.size())
if (parser.i != in.size()) return parser.fail("Unexpected trailing " + esc(in[parser.i]));
return parser.fail("Unexpected trailing " + esc(in[parser.i]));
return result; return result;
} }
// Documented in json11.hpp // Documented in json11.hpp
vector<Json> Json::parse_multi(const string &in, vector<Json> Json::parse_multi(const string &in,
std::string::size_type &parser_stop_pos, std::string::size_type *parser_stop_pos,
string &err, string *err, JsonParse strategy) {
JsonParse strategy) { JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy}; *parser_stop_pos = 0;
parser_stop_pos = 0; vector<Json> json_vec;
vector<Json> json_vec; while (parser.i != in.size() && !parser.failed) {
while (parser.i != in.size() && !parser.failed) { json_vec.push_back(parser.parse_json(0));
json_vec.push_back(parser.parse_json(0)); if (parser.failed) break;
if (parser.failed)
break; // Check for another object
parser.consume_garbage();
// Check for another object if (parser.failed) break;
parser.consume_garbage(); *parser_stop_pos = parser.i;
if (parser.failed) }
break; return json_vec;
parser_stop_pos = parser.i;
}
return json_vec;
} }
/* * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * *
* Shape-checking * Shape-checking
*/ */
bool Json::has_shape(const shape & types, string & err) const { bool Json::has_shape(const shape &types, string *err) const {
if (!is_object()) { if (!is_object()) {
err = "Expected JSON object, got " + dump(); *err = "Expected JSON object, got " + dump();
return false; return false;
} }
for (auto & item : types) { for (auto &item : types) {
if ((*this)[item.first].type() != item.second) { if ((*this)[item.first].type() != item.second) {
err = "Bad type for " + item.first + " in " + dump(); *err = "Bad type for " + item.first + " in " + dump();
return false; return false;
}
} }
}
return true; return true;
} }
} // namespace json11 } // namespace json11
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment