#ifndef JSON_B360EKF1
|
#define JSON_B360EKF1
|
|
#include <algorithm>
|
#include <boost/variant.hpp>
|
#include <map>
|
#include <string>
|
#include <vector>
|
|
namespace ssjson
|
{
|
|
class JValue
|
{
|
public:
|
typedef std::string key_type;
|
typedef long long int_type;
|
typedef long double float_type;
|
typedef JValue value_type;
|
typedef std::map<key_type, value_type> object_type;
|
typedef object_type::value_type pair_type;
|
typedef std::vector<value_type> array_type;
|
|
enum JVType { jv_null,
|
jv_int,
|
jv_float,
|
jv_bool,
|
jv_string,
|
jv_object,
|
jv_array };
|
std::string name() const
|
{
|
static const char *names[] = {"jv_null", "jv_int", "jv_float", "jv_bool", "jv_string", "jv_object", "jv_array"};
|
return names[type()];
|
}
|
|
private:
|
typedef boost::variant<std::nullptr_t, int_type, float_type, bool, std::string, object_type, array_type> data_type;
|
|
template <class C>
|
const C &val() const { return ref_val<C>(); }
|
template <class C>
|
C &val() { return const_cast<C &>(ref_val<C>()); }
|
|
template <class C>
|
class TInitValue
|
{
|
typedef C value_t;
|
typedef std::vector<TInitValue> list_t;
|
mutable boost::variant<value_t, list_t> data_;
|
|
public:
|
template <class T>
|
TInitValue(const T &t) :
|
data_(value_t(t)) {}
|
template <class T>
|
TInitValue(T &&t) :
|
data_(value_t(std::move(t))) {}
|
TInitValue(std::initializer_list<TInitValue> l) :
|
data_(list_t(l)){};
|
bool is_value() const { return data_.which() == 0; }
|
bool is_list() const { return data_.which() == 1; }
|
const list_t &list() const { return boost::get<list_t>(data_); }
|
const value_t &value() const { return boost::get<value_t>(data_); }
|
};
|
typedef TInitValue<JValue> InitValue;
|
typedef std::initializer_list<InitValue> InitList;
|
|
template <class Iter>
|
static object_type MakeObject(Iter begin, Iter end)
|
{
|
object_type obj;
|
for (auto it = begin; it != end; ++it) {
|
obj.emplace(std::move(it->list()[0].value().template val<key_type>()), (it->list()[1]));
|
}
|
return obj;
|
}
|
template <class Iter>
|
static array_type MakeArray(Iter begin, Iter end) { return array_type(begin, end); }
|
template <class Iter>
|
static JValue FromInit(Iter begin, Iter end)
|
{
|
auto like_object_item = [](const InitValue &v) {
|
return v.is_list() &&
|
v.list().size() == 2 &&
|
v.list()[0].is_value() &&
|
v.list()[0].value().type() == jv_string;
|
};
|
if (std::all_of(begin, end, like_object_item)) {
|
return MakeObject(begin, end);
|
} else {
|
return MakeArray(begin, end);
|
}
|
}
|
static JValue FromInit(const InitValue &ji)
|
{
|
if (ji.is_value()) {
|
return std::move(ji.value());
|
} else {
|
return FromInit(ji.list().begin(), ji.list().end());
|
}
|
}
|
|
public:
|
struct DumpOptions {
|
int indent_step_ = 0;
|
int indent_level_ = 0;
|
bool escape_unicode_ = false;
|
};
|
JValue() :
|
data_(object_type()) { static_assert(sizeof(JValue) == sizeof(data_type), "JValue should simple wrap data_type with no other fields."); }
|
#define SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(decl, expr) \
|
JValue(decl) : data_(expr) {} \
|
JValue &operator=(decl) \
|
{ \
|
data_ = (expr); \
|
return *this; \
|
}
|
// operator=() seems faster than JValue(exer).swap(data_).
|
// copy
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(const JValue &v, v.data_) // self;
|
#define MAP_TYPE_TO_JSON_TYPE(decl, expr) \
|
public: \
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(decl, expr) \
|
private: \
|
static auto JVTypeAccept(decl)->std::remove_reference<decltype(expr)>::type
|
#define MAP_TYPE_TO_JSON_TYPE_BIDIR(decl, expr) \
|
MAP_TYPE_TO_JSON_TYPE(decl, expr); \
|
\
|
private: \
|
static auto JVTypeReturn(decl)->std::remove_reference<decltype(expr)>::type
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const std::nullptr_t, nullptr);
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const short v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const unsigned short v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const int v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const unsigned int v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const long v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const unsigned long v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const long long v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const unsigned long long v, int_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const float v, float_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const double v, float_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const long double v, float_type(v));
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const bool v, v);
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const std::string &v, v);
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const object_type &v, v);
|
MAP_TYPE_TO_JSON_TYPE_BIDIR(const array_type &v, v);
|
MAP_TYPE_TO_JSON_TYPE(const char *v, std::string(v));
|
#undef MAP_TYPE_TO_JSON_TYPE_BIDIR
|
#undef MAP_TYPE_TO_JSON_TYPE
|
template <class T>
|
static void JVTypeAccept(T); // use void to disable other types.
|
template <class T>
|
static void JVTypeReturn(T); // use void to disable other types.
|
public:
|
// move
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(JValue &&v, std::move(v.data_)) // self
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(std::string &&v, std::move(v)) // and other classes
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(object_type &&v, std::move(v))
|
SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT(array_type &&v, std::move(v))
|
#undef SUPPORT_CONSTRUCTOR_AND_ASSIGNMENT
|
|
static JValue Object()
|
{
|
return (object_type());
|
}
|
static JValue Object(InitList l) { return (MakeObject(l.begin(), l.end())); }
|
static JValue Array() { return (array_type()); }
|
static JValue Array(InitList l) { return (MakeArray(l.begin(), l.end())); }
|
JValue(InitList l) :
|
JValue(FromInit(l.begin(), l.end())) {}
|
JValue(const InitValue &ji) :
|
JValue(FromInit(ji)) {}
|
JVType type() const { return static_cast<JVType>(data_.which()); }
|
|
std::string dump(const DumpOptions &opt_in) const;
|
std::string dump(const int indent_step = 0, const int indent_level = 0, const bool escape_unicode = false) const
|
{
|
DumpOptions opt;
|
opt.indent_step_ = indent_step;
|
opt.indent_level_ = indent_level;
|
opt.escape_unicode_ = escape_unicode;
|
return dump(opt);
|
}
|
bool parse(const std::string &s) { return parse(s.c_str(), s.c_str() + s.size()) > 0; }
|
int parse(const char *begin, const char *end);
|
void swap(JValue &a) { data_.swap(a.data_); }
|
|
template <class T>
|
T get_value() const { return val<decltype(JVTypeReturn(T()))>(); }
|
template <class T>
|
void put_value(T &&v) { *this = v; }
|
const object_type &object() const { return val<object_type>(); }
|
object_type &object() { return val<object_type>(); }
|
const array_type &array() const { return val<array_type>(); }
|
array_type &array() { return val<array_type>(); }
|
bool is_object() const { return type() == jv_object; }
|
bool is_array() const { return type() == jv_array; }
|
|
// array ops
|
const value_type &operator[](const size_t idx) const { return array()[idx]; }
|
value_type &operator[](const size_t idx) { return array()[idx]; }
|
const value_type &at(const size_t idx) const { return array().at(idx); }
|
value_type &at(const size_t idx) { return array().at(idx); }
|
void push_back(const value_type &v) { array().push_back(v); }
|
void push_back(value_type &&v) { array().push_back(std::move(v)); }
|
|
// object ops
|
value_type &operator[](const key_type &key) { return object()[key]; }
|
const value_type &at(const key_type &key) const { return object().at(key); }
|
value_type &at(const key_type &key) { return object().at(key); }
|
const value_type &child(const key_type &path) const { return ref_child(path); }
|
value_type &child(const key_type &path) { return const_cast<value_type &>(ref_child(path)); }
|
template <class T>
|
T get(const key_type &path) const { return child(path).val<decltype(JVTypeReturn(T()))>(); }
|
template <class T>
|
auto get(const key_type &path, const T &def) const -> typename std::remove_reference<decltype(JVTypeAccept(def))>::type
|
{
|
try {
|
return get<decltype(JVTypeAccept(def))>(path);
|
} catch (...) {
|
return def;
|
}
|
}
|
value_type &put(pair_type &&elem)
|
{
|
const key_type &key = elem.first;
|
auto sep = key.find('.');
|
if (sep == key_type::npos) {
|
auto r = object().lower_bound(elem.first);
|
if (r != object().end() && r->first == elem.first) {
|
r->second = std::move(elem.second);
|
return r->second;
|
} else {
|
return object().emplace_hint(r, std::move(elem))->second;
|
}
|
} else {
|
return (*this)[key.substr(0, sep)].put(pair_type(key.substr(sep + 1), std::move(elem.second)));
|
}
|
}
|
value_type &put(const pair_type &elem)
|
{
|
pair_type tmp(elem);
|
return put(std::move(tmp));
|
}
|
value_type &put(const key_type &k, const value_type &v) { return put(pair_type(k, v)); }
|
value_type &put(const key_type &k, value_type &&v) { return put(pair_type(k, std::move(v))); }
|
value_type &put(key_type &&k, const value_type &v) { return put(pair_type(std::move(k), v)); }
|
value_type &put(key_type &&k, value_type &&v) { return put(pair_type(std::move(k), std::move(v))); }
|
|
private:
|
template <class C>
|
const C &ref_val() const
|
{
|
try {
|
return boost::get<C>(data_);
|
} catch (std::exception &) {
|
throw std::runtime_error("json get error, " + name() + " is not a " + JValue(C()).name());
|
}
|
}
|
const value_type &ref_child(const key_type &path) const
|
{
|
auto sep = path.find('.');
|
if (sep == key_type::npos) {
|
return at(path);
|
} else {
|
return at(path.substr(0, sep)).ref_child(path.substr(sep + 1));
|
}
|
}
|
data_type data_;
|
};
|
|
typedef JValue Json;
|
|
} // namespace ssjson
|
|
#endif // end of include guard: JSON_B360EKF1
|
