toml_value.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_TOML_TOML_VALUE_HPP__
#define NEFORCE_CORE_FILE_TOML_TOML_VALUE_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/time/datetime.hpp"
NEFORCE_BEGIN_NAMESPACE__


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


 
class toml_value;
class toml_boolean;
class toml_integer;
class toml_float;
class toml_string;
class toml_datetime;
class toml_array;
class toml_table;
 

class NEFORCE_API toml_value : public istringify<toml_value> {
public:
    enum types {
        Boolean,  
        Integer,  
        Float,    
        String,   
        DateTime, 
        Array,    
        Table     
    };

    virtual ~toml_value() = default;

    NEFORCE_NODISCARD virtual types type() const noexcept = 0;

    NEFORCE_NODISCARD virtual const toml_boolean* as_boolean() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const toml_integer* as_integer() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const toml_float* as_float() const noexcept { return nullptr; }

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

    NEFORCE_NODISCARD virtual const toml_datetime* as_datetime() const noexcept { return nullptr; }

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

    NEFORCE_NODISCARD virtual const toml_table* as_table() const noexcept { return nullptr; }

    NEFORCE_NODISCARD bool is_boolean() const noexcept { return type() == Boolean; }

    NEFORCE_NODISCARD bool is_integer() const noexcept { return type() == Integer; }

    NEFORCE_NODISCARD bool is_float() const noexcept { return type() == Float; }

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

    NEFORCE_NODISCARD bool is_datetime() const noexcept { return type() == DateTime; }

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

    NEFORCE_NODISCARD bool is_table() const noexcept { return type() == Table; }

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_document() const;
};
 

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

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

    NEFORCE_NODISCARD const toml_boolean* as_boolean() const noexcept override { return this; }

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

class NEFORCE_API toml_integer final : public toml_value {
private:
    int64_t value_; 
 
public:
    explicit toml_integer(const int64_t value) noexcept :
    value_(value) {}

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

    NEFORCE_NODISCARD const toml_integer* as_integer() const noexcept override { return this; }

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

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

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

    NEFORCE_NODISCARD const toml_float* as_float() const noexcept override { return this; }

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

class NEFORCE_API toml_string final : public toml_value {
public:
    enum string_type {
        Basic,       
        Literal,     
        MultiBasic,  
        MultiLiteral 
    };
 
private:
    string value_;     
    string_type type_; 
 
public:
    explicit toml_string(string value, const string_type type = Basic) noexcept :
    value_(_NEFORCE move(value)),
    type_(type) {}

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

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

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

    NEFORCE_NODISCARD string_type get_string_type() const noexcept { return type_; }
};

class NEFORCE_API toml_datetime final : public toml_value {
public:
    enum datetime_type {
        OffsetDateTime, 
        LocalDateTime,  
        LocalDate,      
        LocalTime       
    };
 
private:
    datetime value_;     
    datetime_type type_; 
 
public:
    explicit toml_datetime(const string_view value, const datetime_type type) noexcept :
    type_(type) {
        switch (type_) {
            case datetime_type::OffsetDateTime: {
                datetime dt;
                dt.try_parse_ISO_UTC(value);
                value_ = dt;
                break;
            }
            case datetime_type::LocalDateTime: {
                datetime dt;
                dt.try_parse_ISO(value);
                value_ = dt;
                break;
            }
            case datetime_type::LocalDate: {
                date d{};
                d.try_parse(value);
                value_ = d;
                break;
            }
            case datetime_type::LocalTime: {
                time t{};
                t.try_parse(value);
                value_ = t;
                break;
            }
            default: {
                unreachable();
            }
        }
    }

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

    NEFORCE_NODISCARD const toml_datetime* as_datetime() const noexcept override { return this; }

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

    NEFORCE_NODISCARD string get_string_value() const noexcept {
        switch (type_) {
            case datetime_type::OffsetDateTime: {
                return value_.to_string_ISO_UTC();
            }
            case datetime_type::LocalDateTime: {
                return value_.to_string_ISO();
            }
            case datetime_type::LocalDate: {
                return value_.date().to_string();
            }
            case datetime_type::LocalTime: {
                return value_.time().to_string();
            }
            default: {
                unreachable();
            }
        }
    }

    NEFORCE_NODISCARD datetime_type get_datetime_type() const noexcept { return type_; }
};

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

    toml_array(toml_array&& other) = default;

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

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

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

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

    NEFORCE_NODISCARD const toml_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<toml_value>>& get_elements() const noexcept { return elements_; }
};

class NEFORCE_API toml_table final : public toml_value {
private:
    unordered_map<string, unique_ptr<toml_value>> members_{}; 
    bool is_inline_ = false;                                  
 
public:
    toml_table() = default;

    explicit toml_table(const bool is_inline) :
    is_inline_(is_inline) {}
 
    toml_table(const toml_table&) = delete;
    toml_table& operator=(const toml_table&) = delete;

    toml_table(toml_table&& other) = default;

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

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

    NEFORCE_NODISCARD const toml_table* as_table() const noexcept override { return this; }

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

    NEFORCE_NODISCARD const toml_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 toml_value* get_member(const string& key) {
        const auto it = members_.find(key);
        if (it != members_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD bool has_member(const string& key) const { return members_.find(key) != members_.end(); }

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

    NEFORCE_NODISCARD bool is_inline() const noexcept { return is_inline_; }

    void set_inline(const bool is_inline) noexcept { is_inline_ = is_inline; }
};
 // TomlConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_TOML_TOML_VALUE_HPP__