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 {
 kString,
 kNumber,
 kInteger,
 kObject, // std::map
 kArray, // std::vector
 kBoolean,
 kNull,
 // typed array for ubjson
 kF32Array,
 kF64Array,
 kI8Array,
 kU8Array,
 kI16Array,
 kI32Array,
 kI64Array
 };
 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;
 virtual 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) << "无效的转换，从 " + value->TypeStr() + " 到 " + 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} {}
 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 Type = T;

 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 I32Array = JsonTypedArray<std::int32_t, Value::ValueKind::kI32Array>;
using I64Array = JsonTypedArray<std::int64_t, Value::ValueKind::kI64Array>;

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;
 }

 [[nodiscard]] Json& operator[](std::string const & key) const { return (*ptr_)[key]; }
 [[nodiscard]] 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 {
// 数字
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

/**
 * @brief Get Json value.
 */
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;

/**
 * @brief Convert XGBoost parameter to JSON object.
 */
template <typename Parameter>
Object ToJson(Parameter const& param) {
 Object obj;
 for (auto const& kv : param.__DICT__()) {
 obj[kv.first] = kv.second;
 }
 return obj;
}

/**
 * @brief Load a XGBoost parameter from a JSON object.
 */
template <typename Parameter>
Args FromJson(Json const& obj, Parameter* param) {