json_value.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_JSON_JSON_VALUE_HPP__
#define NEFORCE_CORE_FILE_JSON_JSON_VALUE_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/interface/istringify.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct json_exception final : value_exception {
    explicit json_exception(const char* info = "JSON Operation Failed.", const char* type = static_type,
                            const int code = 0) noexcept :
    value_exception(info, type, code) {}
 
    explicit json_exception(const exception& e) :
    value_exception(e) {}
 
    ~json_exception() override = default;
    static constexpr auto static_type = "json_exception";
};
 // Exceptions


 
class json_value;
class json_null;
class json_bool;
class json_number;
class json_string;
class json_object;
class json_array;
 

class NEFORCE_API json_value : public istringify<json_value> {
public:
    enum types {
        Null,   
        Bool,   
        Number, 
        String, 
        Object, 
        Array   
    };

    virtual ~json_value() = default;

    NEFORCE_NODISCARD virtual types type() const noexcept = 0;

    NEFORCE_NODISCARD virtual const json_null* as_null() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const json_bool* as_bool() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const json_number* as_number() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const json_string* as_string() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const json_object* as_object() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const json_array* as_array() const noexcept { return nullptr; }

    NEFORCE_NODISCARD bool is_null() const noexcept { return type() == Null; }

    NEFORCE_NODISCARD bool is_bool() const noexcept { return type() == Bool; }

    NEFORCE_NODISCARD bool is_number() const noexcept { return type() == Number; }

    NEFORCE_NODISCARD bool is_string() const noexcept { return type() == String; }

    NEFORCE_NODISCARD bool is_object() const noexcept { return type() == Object; }

    NEFORCE_NODISCARD bool is_array() const noexcept { return type() == Array; }

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_indent_string() const;
};
 

class NEFORCE_API json_null final : public json_value {
public:
    NEFORCE_NODISCARD types type() const noexcept override { return Null; }

    NEFORCE_NODISCARD const json_null* as_null() const noexcept override { return this; }
};

class NEFORCE_API json_bool final : public json_value {
private:
    bool value_; 
 
public:
    explicit json_bool(const bool value) noexcept :
    value_(value) {}

    NEFORCE_NODISCARD types type() const noexcept override { return Bool; }

    NEFORCE_NODISCARD const json_bool* as_bool() const noexcept override { return this; }

    NEFORCE_NODISCARD bool get_value() const noexcept { return value_; }
};

class NEFORCE_API json_number final : public json_value {
private:
    double value_; 
 
public:
    explicit json_number(const double value) noexcept :
    value_(value) {}

    NEFORCE_NODISCARD types type() const noexcept override { return Number; }

    NEFORCE_NODISCARD const json_number* as_number() const noexcept override { return this; }

    NEFORCE_NODISCARD double get_value() const noexcept { return value_; }
};

class NEFORCE_API json_string final : public json_value {
private:
    string value_; 
 
public:
    explicit json_string(string value) noexcept :
    value_(_NEFORCE move(value)) {}

    NEFORCE_NODISCARD types type() const noexcept override { return String; }

    NEFORCE_NODISCARD const json_string* as_string() const noexcept override { return this; }

    NEFORCE_NODISCARD const string& get_value() const noexcept { return value_; }
};

class NEFORCE_API json_object final : public json_value {
private:
    unordered_map<string, unique_ptr<json_value>> members_{}; 
 
public:
    json_object() = default;
 
    json_object(const json_object&) = delete;
    json_object& operator=(const json_object&) = delete;

    json_object(json_object&& other) = default;

    json_object& operator=(json_object&& other) = default;

    NEFORCE_NODISCARD types type() const noexcept override { return Object; }

    NEFORCE_NODISCARD const json_object* as_object() const noexcept override { return this; }

    void add_member(const string& key, unique_ptr<json_value> value) { members_[key] = _NEFORCE move(value); }

    NEFORCE_NODISCARD const json_value* get_member(const string& key) const {
        const auto it = members_.find(key);
        if (it != members_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD const unordered_map<string, unique_ptr<json_value>>& get_members() const noexcept {
        return members_;
    }
};

class NEFORCE_API json_array final : public json_value {
private:
    vector<unique_ptr<json_value>> elements_; 
 
public:
    json_array() = default;
 
    json_array(const json_array&) = delete;
    json_array& operator=(const json_array&) = delete;

    json_array(json_array&& other) = default;

    json_array& operator=(json_array&& other) = default;

    NEFORCE_NODISCARD types type() const noexcept override { return Array; }

    NEFORCE_NODISCARD const json_array* as_array() const noexcept override { return this; }

    void add_element(unique_ptr<json_value> value) { elements_.emplace_back(_NEFORCE move(value)); }

    NEFORCE_NODISCARD const json_value* get_element(const size_t index) const noexcept {
        if (index < elements_.size()) {
            return elements_[index].get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD size_t size() const noexcept { return elements_.size(); }

    NEFORCE_NODISCARD const vector<unique_ptr<json_value>>& get_elements() const noexcept { return elements_; }
};
 // JsonConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_JSON_JSON_VALUE_HPP__