json.h

前往此文件文档。

 
#ifndef XGBOOST_JSON_H_
#define XGBOOST_JSON_H_
 
#include <xgboost/intrusive_ptr.h>
#include <xgboost/logging.h>
#include <xgboost/parameter.h>
#include <xgboost/string_view.h>
 
#include <functional>
#include <map>
#include <string>
#include <type_traits> // std::enable_if_t
#include <utility>
#include <vector>
 
namespace xgboost {
 
class Json;
class JsonReader;
class JsonWriter;
 
class Value {
 private
 mutable class IntrusivePtrCell ref_;
 friend IntrusivePtrCell& IntrusivePtrRefCount(xgboost::Value const* t) noexcept {
 return t->ref_;
  }
 
 public
 enum class ValueKind : std::int64_t {
 kString = 0,
 kNumber = 1,
 kInteger = 2,
 kObject = 3, // std::map
 kArray = 4, // std::vector
 kBoolean = 5,
 kNull = 6,
 // typed array for ubjson
 kF32Array = 7,
 kF64Array = 8,
 kI8Array = 9,
 kU8Array = 10,
 kI16Array = 11,
 kU16Array = 12,
 kI32Array = 13,
 kU32Array = 14,
 kI64Array = 15,
 kU64Array = 16,
  };
 
 explicit Value(ValueKind _kind) : kind_{_kind} {}
 
 ValueKind Type() const { return kind_; }
 virtual ~Value() = default;
 
 virtual void Save(JsonWriter* writer) const = 0;
 
 virtual Json& operator[](std::string const& key);
 virtual Json& operator[](int ind);
 
 virtual bool operator==(Value const& rhs) const = 0;
 Value& operator=(Value const& rhs) = delete;
 
 std::string TypeStr() const;
 
 private
 ValueKind kind_;
};
 
template <typename T>
bool IsA(Value const* value) {
 return T::IsClassOf(value);
}
 
template <typename T, typename U>
T* Cast(U* value) {
 if (IsA<T>(value)) {
 return dynamic_cast<T*>(value);
 } else {
 LOG(FATAL) << "Invalid cast, from " + value->TypeStr() + " to " + T().TypeStr();
  }
 return dynamic_cast<T*>(value); // 抑制编译器警告。
}
 
class JsonString : public Value {
 std::string str_;
 
 public
 JsonString() : Value(ValueKind::kString) {}
 JsonString(std::string const& str) : // NOLINT
 Value(ValueKind::kString), str_{str} {}
 JsonString(std::string&& str) noexcept : // NOLINT
 Value(ValueKind::kString), str_{std::forward<std::string>(str)} {}
 JsonString(JsonString&& str) noexcept : Value(ValueKind::kString) { // NOLINT
 std::swap(str.str_, this->str_);
  }
 
 void Save(JsonWriter* writer) const override;
 
 std::string const& GetString() && { return str_; }
 std::string const& GetString() const & { return str_; }
 std::string& GetString() & { return str_; }
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kString;
  }
};
 
class JsonArray : public Value {
 std::vector<Json> vec_;
 
 public
 JsonArray() : Value(ValueKind::kArray) {}
 JsonArray(std::vector<Json>&& arr) noexcept // NOLINT
 : Value(ValueKind::kArray), vec_{std::forward<std::vector<Json>>(arr)} {}
 JsonArray(std::vector<Json> const& arr) : // NOLINT
 Value(ValueKind::kArray), vec_{arr} {}
 JsonArray(JsonArray const& that) = delete;
 JsonArray(JsonArray && that) noexcept;
 
 void Save(JsonWriter* writer) const override;
 
 Json& operator[](int ind) override { return vec_.at(ind); }
 // 消除部分重载警告
 Json& operator[](std::string const& key) override { return Value::operator[](key); }
 
 std::vector<Json> const& GetArray() && { return vec_; }
 std::vector<Json> const& GetArray() const & { return vec_; }
 std::vector<Json>& GetArray() & { return vec_; }
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kArray;
  }
};
 
template <typename T, Value::ValueKind kind>
class JsonTypedArray : public Value {
 std::vector<T> vec_;
 
 public
 using value_type = T; // NOLINT
 
 JsonTypedArray() : Value(kind) {}
 explicit JsonTypedArray(std::size_t n) : Value(kind) { vec_.resize(n); }
 JsonTypedArray(JsonTypedArray&& that) noexcept : Value{kind}, vec_{std::move(that.vec_)} {}
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 void Set(size_t i, T v) { vec_[i] = v; }
 size_t Size() const { return vec_.size(); }
 
 void Save(JsonWriter* writer) const override;
 
 std::vector<T> const& GetArray() && { return vec_; }
 std::vector<T> const& GetArray() const& { return vec_; }
 std::vector<T>& GetArray() & { return vec_; }
 
 static bool IsClassOf(Value const* value) { return value->Type() == kind; }
};
 
using F32Array = JsonTypedArray<float, Value::ValueKind::kF32Array>;
using F64Array = JsonTypedArray<double, Value::ValueKind::kF64Array>;
using I8Array = JsonTypedArray<std::int8_t, Value::ValueKind::kI8Array>;
using U8Array = JsonTypedArray<std::uint8_t, Value::ValueKind::kU8Array>;
using I16Array = JsonTypedArray<std::int16_t, Value::ValueKind::kI16Array>;
using U16Array = JsonTypedArray<std::uint16_t, Value::ValueKind::kU16Array>;
using I32Array = JsonTypedArray<std::int32_t, Value::ValueKind::kI32Array>;
using U32Array = JsonTypedArray<std::uint32_t, Value::ValueKind::kU32Array>;
using I64Array = JsonTypedArray<std::int64_t, Value::ValueKind::kI64Array>;
using U64Array = JsonTypedArray<std::uint64_t, Value::ValueKind::kU64Array>;
 
class JsonObject : public Value {
 public
 using Map = std::map<std::string, Json, std::less<>>;
 
 private
 Map object_;
 
 public
 JsonObject() : Value(ValueKind::kObject) {}
 JsonObject(Map&& object) noexcept; // NOLINT
 JsonObject(JsonObject const& that) = delete;
 JsonObject(JsonObject&& that) noexcept;
 
 void Save(JsonWriter* writer) const override;
 
 // 消除部分重载警告
 Json& operator[](int ind) override { return Value::operator[](ind); }
 Json& operator[](std::string const& key) override { return object_[key]; }
 
 Map const& GetObject() && { return object_; }
 Map const& GetObject() const& { return object_; }
 Map& GetObject() & { return object_; }
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) { return value->Type() == ValueKind::kObject; }
 ~JsonObject() override = default;
};
 
namespace detail {
template <typename T, typename U>
using IsSameT = std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::remove_cv_t<U>>>;
 
template <typename T>
using IsF64T = std::enable_if_t<std::is_same_v<T, double>>;
} // namespace detail
 
class JsonNumber : public Value {
 public
 using Float = float;
 
 private
 Float number_ { 0 };
 
 public
 JsonNumber() : Value(ValueKind::kNumber) {}
 template <typename FloatT, typename detail::IsSameT<FloatT, Float>* = nullptr>
 JsonNumber(FloatT value) : Value(ValueKind::kNumber), number_{value} {} // NOLINT
 template <typename FloatT, typename detail::IsF64T<FloatT>* = nullptr>
 JsonNumber(FloatT value) // NOLINT
 : Value{ValueKind::kNumber}, number_{static_cast<Float>(value)} {}
 JsonNumber(JsonNumber const& that) = delete;
 JsonNumber(JsonNumber&& that) noexcept : Value{ValueKind::kNumber}, number_{that.number_} {}
 
 void Save(JsonWriter* writer) const override;
 
 Float const& GetNumber() && { return number_; }
 Float const& GetNumber() const & { return number_; }
 Float& GetNumber() & { return number_; }
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kNumber;
  }
};
 
namespace detail {
template <typename IntT>
using Not32SizeT = std::enable_if_t<std::is_same_v<IntT, std::uint32_t> &&
 !std::is_same_v<std::size_t, std::uint32_t>>;
}
 
 
class JsonInteger : public Value {
 public
 using Int = int64_t;
 
 private
 Int integer_ {0};
 
 public
 JsonInteger() : Value(ValueKind::kInteger) {} // NOLINT
 template <typename IntT, typename detail::IsSameT<IntT, Int>* = nullptr>
 JsonInteger(IntT value) : Value(ValueKind::kInteger), integer_{value} {} // NOLINT
 template <typename IntT, typename detail::IsSameT<IntT, std::size_t>* = nullptr>
 JsonInteger(IntT value) // NOLINT
 : Value(ValueKind::kInteger), integer_{static_cast<Int>(value)} {}
 template <typename IntT, typename detail::IsSameT<IntT, std::int32_t>* = nullptr>
 JsonInteger(IntT value) // NOLINT
 : Value(ValueKind::kInteger), integer_{static_cast<Int>(value)} {}
 template <typename IntT,
 typename detail::Not32SizeT<IntT>* = nullptr>
 JsonInteger(IntT value) // NOLINT
 : Value(ValueKind::kInteger), integer_{static_cast<Int>(value)} {}
 
 JsonInteger(JsonInteger &&that) noexcept
 : Value{ValueKind::kInteger}, integer_{that.integer_} {}
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 Int const& GetInteger() && { return integer_; }
 Int const& GetInteger() const & { return integer_; }
 Int& GetInteger() & { return integer_; }
 void Save(JsonWriter* writer) const override;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kInteger;
  }
};
 
class JsonNull : public Value {
 public
 JsonNull() : Value(ValueKind::kNull) {}
 JsonNull(std::nullptr_t) : Value(ValueKind::kNull) {} // NOLINT
 JsonNull(JsonNull&&) noexcept : Value(ValueKind::kNull) {}
 
 void Save(JsonWriter* writer) const override;
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kNull;
  }
};
 
class JsonBoolean : public Value {
 bool boolean_ = false;
 
 public
 JsonBoolean() : Value(ValueKind::kBoolean) {} // NOLINT
 // 与JsonNumber有歧义。
 template <typename Bool, typename detail::IsSameT<std::remove_cv_t<Bool>, bool>* = nullptr>
 JsonBoolean(Bool value) : Value(ValueKind::kBoolean), boolean_{value} {} // NOLINT
 JsonBoolean(JsonBoolean&& value) noexcept: // NOLINT
 Value(ValueKind::kBoolean), boolean_{value.boolean_} {}
 
 void Save(JsonWriter* writer) const override;
 
 bool const& GetBoolean() && { return boolean_; }
 bool const& GetBoolean() const & { return boolean_; }
 bool& GetBoolean() & { return boolean_; }
 
 bool operator==(Value const& rhs) const override;
 Value& operator=(Value const& rhs) override = delete;
 
 static bool IsClassOf(Value const* value) {
 return value->Type() == ValueKind::kBoolean;
  }
};
 
class Json {
 public
 static Json Load(StringView str, std::ios::openmode mode = std::ios::in);
 static Json Load(JsonReader* reader);
 static void Dump(Json json, std::string* out, std::ios::openmode mode = std::ios::out);
 static void Dump(Json json, std::vector<char>* out, std::ios::openmode mode = std::ios::out);
 static void Dump(Json json, JsonWriter* writer);
 
 template <typename Container = std::string>
 static Container Dump(Json json) {
 if constexpr (std::is_same_v<Container, std::string>) {
 std::string str;
 Dump(json, &str);
 return str;
 } else {
 std::vector<char> str;
 Dump(json, &str);
 return str;
    }
  }
 
 Json() = default;
 
 // 数字
 explicit Json(JsonNumber number) : ptr_{new JsonNumber(std::move(number))} {}
 Json& operator=(JsonNumber number) {
 ptr_.reset(new JsonNumber(std::move(number)));
 return *this;
  }
 // 整数
 explicit Json(JsonInteger integer) : ptr_{new JsonInteger(std::move(integer))} {}
 Json& operator=(JsonInteger integer) {
 ptr_.reset(new JsonInteger(std::move(integer)));
 return *this;
  }
 // 数组
 explicit Json(JsonArray&& list) : ptr_{new JsonArray(std::forward<JsonArray>(list))} {}
 Json& operator=(JsonArray&& array) {
 ptr_.reset(new JsonArray(std::forward<JsonArray>(array)));
 return *this;
  }
 // 类型化数组
 template <typename T, Value::ValueKind kind>
 explicit Json(JsonTypedArray<T, kind>&& list)
 : ptr_{new JsonTypedArray<T, kind>(std::forward<JsonTypedArray<T, kind>>(list))} {}
 template <typename T, Value::ValueKind kind>
 Json& operator=(JsonTypedArray<T, kind>&& array) {
 ptr_.reset(new JsonTypedArray<T, kind>(std::forward<JsonTypedArray<T, kind>>(array)));
 return *this;
  }
 // 对象
 explicit Json(JsonObject&& object) : ptr_{new JsonObject(std::forward<JsonObject>(object))} {}
 Json& operator=(JsonObject&& object) {
 ptr_.reset(new JsonObject(std::forward<JsonObject>(object)));
 return *this;
  }
 // 字符串
 explicit Json(JsonString&& str) : ptr_{new JsonString(std::forward<JsonString>(str))} {}
 Json& operator=(JsonString&& str) {
 ptr_.reset(new JsonString(std::forward<JsonString>(str)));
 return *this;
  }
 // 布尔值
 explicit Json(JsonBoolean boolean)
 ptr_{new JsonBoolean(std::move(boolean))} {}
 Json& operator=(JsonBoolean boolean) {
 ptr_.reset(new JsonBoolean(std::move(boolean)));
 return *this;
  }
 // 空值
 explicit Json(JsonNull null)
 ptr_{new JsonNull(std::move(null))} {}
 Json& operator=(JsonNull null) {
 ptr_.reset(new JsonNull(std::move(null)));
 return *this;
  }
 
 // 复制
 Json(Json const& other) = default;
 Json& operator=(Json const& other) = default;
 // 移动
 Json(Json &&other) noexcept { std::swap(this->ptr_, other.ptr_); }
 Json &operator=(Json &&other) noexcept {
 std::swap(this->ptr_, other.ptr_);
 return *this;
  }
 
 Json& operator[](std::string const & key) const { return (*ptr_)[key]; }
 Json& operator[](int ind) const { return (*ptr_)[ind]; }
 
 [[nodiscard]] Value const& GetValue() const& { return *ptr_; }
 Value const& GetValue() && { return *ptr_; }
 Value& GetValue() & { return *ptr_; }
 
 bool operator==(Json const& rhs) const {
 return *ptr_ == *(rhs.ptr_);
  }
 
 friend std::ostream& operator<<(std::ostream& os, Json const& j) {
 std::string str;
 Json::Dump(j, &str);
 os << str;
 return os;
  }
 
 [[nodiscard]] IntrusivePtr<Value> const& Ptr() const { return ptr_; }
 
 private
 IntrusivePtr<Value> ptr_{new JsonNull};
};
 
template <typename T>
bool IsA(Json const& j) {
 auto const& v = j.GetValue();
 return IsA<T>(&v);
}
 
namespace detail {
// Number
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonNumber>>* = nullptr>
JsonNumber::Float& GetImpl(T& val) { // NOLINT
 return val.GetNumber();
}
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonNumber const>>* = nullptr>
JsonNumber::Float const& GetImpl(T& val) { // NOLINT
 return val.GetNumber();
}
 
// Integer
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonInteger>>* = nullptr>
JsonInteger::Int& GetImpl(T& val) { // NOLINT
 return val.GetInteger();
}
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonInteger const>>* = nullptr>
JsonInteger::Int const& GetImpl(T& val) { // NOLINT
 return val.GetInteger();
}
 
// String
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonString>>* = nullptr>
std::string& GetImpl(T& val) { // NOLINT
 return val.GetString();
}
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonString const>>* = nullptr>
std::string const& GetImpl(T& val) { // NOLINT
 return val.GetString();
}
 
// Boolean
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonBoolean>>* = nullptr>
bool& GetImpl(T& val) { // NOLINT
 return val.GetBoolean();
}
template <typename T,
 typename std::enable_if_t<std::is_same_v<T, JsonBoolean const>>* = nullptr>
bool const& GetImpl(T& val) { // NOLINT
 return val.GetBoolean();
}
 
// Array
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonArray>>* = nullptr>
std::vector<Json>& GetImpl(T& val) { // NOLINT
 return val.GetArray();
}
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonArray const>>* = nullptr>
std::vector<Json> const& GetImpl(T& val) { // NOLINT
 return val.GetArray();
}
 
// Typed Array
template <typename T, Value::ValueKind kind>
std::vector<T>& GetImpl(JsonTypedArray<T, kind>& val) { // NOLINT
 return val.GetArray();
}
template <typename T, Value::ValueKind kind>
std::vector<T> const& GetImpl(JsonTypedArray<T, kind> const& val) {
 return val.GetArray();
}
 
// Object
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonObject>>* = nullptr>
JsonObject::Map& GetImpl(T& val) { // NOLINT
 return val.GetObject();
}
template <typename T, typename std::enable_if_t<std::is_same_v<T, JsonObject const>>* = nullptr>
JsonObject::Map const& GetImpl(T& val) { // NOLINT
 return val.GetObject();
}
} // namespace detail
 
template <typename T, typename U>
auto get(U& json) -> decltype(detail::GetImpl(*Cast<T>(&json.GetValue())))& { // NOLINT
 auto& value = *Cast<T>(&json.GetValue());
 return detail::GetImpl(value);
}
 
using Object = JsonObject;
using Array = JsonArray;
using Number = JsonNumber;
using Integer = JsonInteger;
using Boolean = JsonBoolean;
using String = JsonString;
using Null = JsonNull;
 
template <typename Parameter>
Object ToJson(Parameter const& param) {
 Object obj;
 for (auto const& kv : param.__DICT__()) {
 obj[kv.first] = kv.second;
  }
 return obj;
}
 
template <typename Parameter>
Args FromJson(Json const& obj, Parameter* param) {
 auto const& j_param = get<Object const>(obj);
 Args args;
 for (auto const& kv : j_param) {
 args.emplace_back(kv.first, get<String const>(kv.second));
  }
 return param->UpdateAllowUnknown(args);
}
} // namespace xgboost
#endif // XGBOOST_JSON_H_