Value.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <map>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
namespace eve {
 
class EVENGINE_API_FOUNDATION Value {
public:
    using Array   = std::vector<Value>;
    using Object  = std::map<std::string, Value>;
    using Storage = std::variant<std::monostate, bool, std::int64_t, double, std::string, Array, Object>;
 
    enum class Type : std::uint8_t {
        Null = 0,
        Bool,
        Int64,
        Double,
        String,
        Array,
        Object,
        Integer = Int64,
        Number = Double,
        Int = Int64,
        Float = Double,
    };
 
    using Kind = Type;
 
    Value() = default;
    Value(std::nullptr_t) {}
    Value(bool value) : storage_(value) {}
    Value(std::int64_t value) : storage_(value) {}
    Value(int value) : storage_(static_cast<std::int64_t>(value)) {}
    Value(double value) : storage_(value) {}
    Value(float value) : storage_(static_cast<double>(value)) {}
    Value(const char* value) : storage_(std::string(value ? value : "")) {}
    Value(std::string value) : storage_(std::move(value)) {}
    Value(Array value) : storage_(std::move(value)) {}
    Value(Object value) : storage_(std::move(value)) {}
 
    Type type() const noexcept { return static_cast<Type>(storage_.index()); }
    Type kind() const noexcept { return type(); }
    bool isNull() const noexcept { return type() == Type::Null; }
    bool isBool() const noexcept { return type() == Type::Bool; }
    bool isInt64() const noexcept { return type() == Type::Int64; }
    bool isDouble() const noexcept { return type() == Type::Double; }
    bool isString() const noexcept { return type() == Type::String; }
    bool isArray() const noexcept { return type() == Type::Array; }
    bool isObject() const noexcept { return type() == Type::Object; }
 
    static Value null() { return Value(); }
    static Value integer(std::int64_t value) { return Value(value); }
    static Value number(double value) { return Value(value); }
    static Value boolean(bool value) { return Value(value); }
    static Value string(std::string value) { return Value(std::move(value)); }
    static Value array(Array value) { return Value(std::move(value)); }
    static Value object(Object value) { return Value(std::move(value)); }
 
    std::int64_t asInt() const;
    double asDouble() const;
    bool asBool() const;
    const std::string& asString() const;
 
    void pushBack(Value value);
    std::size_t arraySize() const;
    Value& at(std::size_t index);
    const Value& at(std::size_t index) const;
    void set(const std::string& key, Value value);
    Value* find(const std::string& key) noexcept;
    const Value* find(const std::string& key) const noexcept;
    std::vector<std::string> keys() const;
 
    bool isNumeric() const noexcept { return isInt64() || isDouble(); }
    std::string typeName() const;
    std::string toString() const;
 
    const Storage& storage() const noexcept { return storage_; }
    Storage& storage() noexcept { return storage_; }
 
    template <class T>
    const T* getIf() const noexcept {
        return std::get_if<T>(&storage_);
    }
 
    template <class T>
    T* getIf() noexcept {
        return std::get_if<T>(&storage_);
    }
 
    [[nodiscard]] static Result<Value> fromJson(std::string_view json);
 
    [[nodiscard]] Result<std::string> toJson() const;
 
    bool operator==(const Value&) const = default;
 
private:
    Storage storage_;
};
 
}  // namespace eve