json.h

#ifndef UTIL_JSON_H_
#define UTIL_JSON_H_
 
#include <functional>
#include <initializer_list>
#include <iostream>
#include <string>
#include <utility>
 
#include "picojson.h"
 
class JsonObject;
class JsonArray;
 
class JsonValue {
 public:
  JsonValue() : v() {}
 
  JsonValue(picojson::value val) : v(std::move(val)) {}
 
  JsonValue(double d) : v(d) {}
 
  JsonValue(int i) : v(static_cast<double>(i)) {}
 
  JsonValue(const std::string& s) : v(s) {}
 
  JsonValue(const char* s) : v(s) {}
 
  JsonValue(bool b) : v(b) {}
 
  JsonValue(const JsonObject& o);
 
  JsonValue(const JsonArray& a);
 
  ~JsonValue();
 
  JsonValue(const JsonValue& other);
 
  JsonValue& operator=(const JsonValue& other);
 
  JsonValue(JsonValue&& other);
 
  JsonValue& operator=(JsonValue&& other) noexcept;
 
  static JsonValue fromReference(picojson::value& v);
 
  picojson::value& getValue() { return isRef ? ref.get() : v; }
 
  const picojson::value& getValue() const { return isRef ? ref.get() : v; }
 
  // DOUBLE
 
  operator double() const { return get<double>(); }
 
  JsonValue& operator=(double d) {
    set(d);
    return *this;
  }
 
  // FLOAT
 
  operator float() const { return static_cast<float>(get<double>()); }
 
  JsonValue& operator=(float f) {
    set(static_cast<double>(f));
    return *this;
  }
 
  // INT
 
  operator int() const { return static_cast<int>(get<double>()); }
 
  JsonValue& operator=(int i) {
    set(static_cast<double>(i));
    return *this;
  }
 
  // STRING
 
  operator std::string() const { return get<std::string>(); }
 
  JsonValue& operator=(const std::string& s) {
    set(s);
    return *this;
  }
 
  JsonValue& operator=(const char* s) {
    set(s);
    return *this;
  }
 
  // BOOL
 
  operator bool() const { return get<bool>(); }
 
  JsonValue& operator=(bool b) {
    set(b);
    return *this;
  }
 
  // JSON OBJECT
 
  operator JsonObject() const;
 
  JsonValue& operator=(const JsonObject& o);
 
  // JSON ARRAY
 
  operator JsonArray() const;
 
  JsonValue& operator=(const JsonArray& a);
 
  std::string toString() const { return getValue().serialize(); }
 
 protected:
  template <class T>
  T get() const {
    return getValue().get<T>();
  }
 
  template <class T>
  void set(const T& t) {
    getValue() = picojson::value(t);
  }
 
  union {
    picojson::value v;
    std::reference_wrapper<picojson::value> ref;
  };
 
  bool isRef = false;
};
 
class JsonObject {
 public:
  JsonObject() = default;
 
  JsonObject(picojson::object obj) : obj(std::move(obj)) {}
 
  JsonValue operator[](const std::string& key) {
    return JsonValue::fromReference(obj[key]);
  }
 
  JsonValue operator[](const std::string& key) const { return obj.at(key); }
 
  picojson::object& getObject() { return obj; }
 
  const picojson::object& getObject() const { return obj; }
 
  std::string toString() const { return picojson::value(obj).serialize(); }
 
  bool contains(const std::string& key) const {
    return obj.find(key) != obj.end();
  }
 
  std::vector<std::string> getKeys() const;
 
 protected:
  picojson::object obj;
};
 
class JsonArray {
 public:
  JsonArray() = default;
 
  JsonArray(picojson::array arr) : arr(std::move(arr)) {}
 
  JsonArray(const std::initializer_list<JsonValue> ls) {
    for (const auto& val : ls) push(val);
  }
 
  explicit JsonArray(int size) : arr(size) {}
 
  picojson::array& getArray() { return arr; }
 
  const picojson::array& getArray() const { return arr; }
 
  std::string toString() const { return picojson::value(arr).serialize(); }
 
  JsonValue operator[](int idx) { return JsonValue::fromReference(arr[idx]); }
 
  JsonValue operator[](int idx) const { return arr.at(idx); }
 
  JsonValue at(int idx) const { return arr.at(idx); }
 
  void push(const JsonValue& val) { arr.push_back(val.getValue()); }
 
  int size() const { return arr.size(); }
 
  void resize(int size) { arr.resize(size); }
 
 protected:
  picojson::array arr;
};
 
inline JsonValue::~JsonValue() {
  if (!isRef) {
    v.~value();
  }
}
 
inline JsonValue::JsonValue(const JsonValue& other) {
  isRef = other.isRef;
  if (isRef) {
    ref = other.ref;
  } else {
    v = other.v;
  }
}
 
inline JsonValue& JsonValue::operator=(const JsonValue& other) {
  if (this != &other) {
    isRef = other.isRef;
    if (isRef) {
      ref = other.ref;
    } else {
      v = other.v;
    }
  }
  return *this;
}
 
inline JsonValue::JsonValue(JsonValue&& other) {
  isRef = other.isRef;
  if (isRef) {
    ref = other.ref;
  } else {
    v = std::move(other.v);
  }
}
 
inline JsonValue& JsonValue::operator=(JsonValue&& other) noexcept {
  isRef = other.isRef;
  if (isRef) {
    ref = other.ref;
  } else {
    v = std::move(other.v);
  }
  return *this;
}
 
inline JsonValue JsonValue::fromReference(picojson::value& v) {
  JsonValue val;
  val.ref = v;
  val.isRef = true;
  return val;
}
 
inline JsonValue& JsonValue::operator=(const JsonObject& o) {
  set(o.getObject());
  return *this;
}
 
inline JsonValue::operator JsonObject() const {
  return {get<picojson::object>()};
}
 
inline JsonValue& JsonValue::operator=(const JsonArray& a) {
  set(a.getArray());
  return *this;
}
 
inline JsonValue::operator JsonArray() const {
  return {get<picojson::array>()};
}
 
inline JsonValue::JsonValue(const JsonObject& o) : v(o.getObject()) {}
 
inline JsonValue::JsonValue(const JsonArray& a) : v(a.getArray()) {}
 
inline std::vector<std::string> JsonObject::getKeys() const {
  std::vector<std::string> keys;
  for (const auto& kv : obj) {
    keys.push_back(kv.first);
  }
  return keys;
}
 
inline std::ostream& operator<<(std::ostream& os, const JsonValue& val) {
  os << val.toString();
  return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const JsonObject& obj) {
  os << obj.toString();
  return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const JsonArray& array) {
  os << array.toString();
  return os;
}
 
#endif  // UTIL_JSON_H_