yaml_value.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_YAML_YAML_VALUE_HPP__
#define NEFORCE_CORE_FILE_YAML_YAML_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/shared_ptr.hpp"
#include "NeForce/core/time/datetime.hpp"
NEFORCE_BEGIN_NAMESPACE__


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


 
class yaml_value;
class yaml_null;
class yaml_boolean;
class yaml_integer;
class yaml_float;
class yaml_string;
class yaml_timestamp;
class yaml_sequence;
class yaml_mapping;
 

class NEFORCE_API yaml_value : public istringify<yaml_value> {
public:
    string anchor; 
    string tag;    

    enum types {
        Null,      
        Boolean,   
        Integer,   
        Float,     
        String,    
        Timestamp, 
        Sequence,  
        Mapping    
    };
 
    yaml_value() = default;
    virtual ~yaml_value() = default;
 
    yaml_value(const yaml_value&) = default;
    yaml_value& operator=(const yaml_value&) = default;
 
    yaml_value(yaml_value&&) noexcept = default;
    yaml_value& operator=(yaml_value&&) noexcept = default;

    NEFORCE_NODISCARD virtual types type() const noexcept = 0;

    NEFORCE_NODISCARD virtual const yaml_null* as_null() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_boolean* as_boolean() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_integer* as_integer() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_float* as_float() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_string* as_string() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_timestamp* as_timestamp() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_sequence* as_sequence() const noexcept { return nullptr; }
    NEFORCE_NODISCARD virtual const yaml_mapping* as_mapping() const noexcept { return nullptr; }

    NEFORCE_NODISCARD bool is_null() const noexcept { return type() == Null; }
    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_timestamp() const noexcept { return type() == Timestamp; }
    NEFORCE_NODISCARD bool is_sequence() const noexcept { return type() == Sequence; }
    NEFORCE_NODISCARD bool is_mapping() const noexcept { return type() == Mapping; }

    void set_anchor(const string& a) { this->anchor = a; }

    void set_tag(const string& t) { this->tag = t; }

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_document() const;
};

class NEFORCE_API yaml_null final : public yaml_value {
public:
    yaml_null() = default;
    ~yaml_null() override = default;
 
    yaml_null(const yaml_null&) = default;
    yaml_null& operator=(const yaml_null&) = default;
    yaml_null(yaml_null&&) noexcept = default;
    yaml_null& operator=(yaml_null&&) noexcept = default;
 
    NEFORCE_NODISCARD types type() const noexcept override { return Null; }
    NEFORCE_NODISCARD const yaml_null* as_null() const noexcept override { return this; }
};

class NEFORCE_API yaml_boolean final : public yaml_value {
private:
    bool value; 
 
public:
    ~yaml_boolean() override = default;
 
    yaml_boolean(const yaml_boolean&) = default;
    yaml_boolean& operator=(const yaml_boolean&) = default;
    yaml_boolean(yaml_boolean&&) noexcept = default;
    yaml_boolean& operator=(yaml_boolean&&) noexcept = default;

    explicit yaml_boolean(const bool v) :
    value(v) {}
 
    NEFORCE_NODISCARD types type() const noexcept override { return Boolean; }
    NEFORCE_NODISCARD const yaml_boolean* as_boolean() const noexcept override { return this; }

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

class NEFORCE_API yaml_integer final : public yaml_value {
private:
    int64_t value; 
 
public:
    ~yaml_integer() override = default;
 
    yaml_integer(const yaml_integer&) = default;
    yaml_integer& operator=(const yaml_integer&) = default;
    yaml_integer(yaml_integer&&) noexcept = default;
    yaml_integer& operator=(yaml_integer&&) noexcept = default;

    explicit yaml_integer(const int64_t v) :
    value(v) {}
 
    NEFORCE_NODISCARD types type() const noexcept override { return Integer; }
    NEFORCE_NODISCARD const yaml_integer* as_integer() const noexcept override { return this; }

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

class NEFORCE_API yaml_float final : public yaml_value {
private:
    double value; 
 
public:
    ~yaml_float() override = default;
 
    yaml_float(const yaml_float&) = default;
    yaml_float& operator=(const yaml_float&) = default;
    yaml_float(yaml_float&&) noexcept = default;
    yaml_float& operator=(yaml_float&&) noexcept = default;

    explicit yaml_float(const double v) :
    value(v) {}
 
    NEFORCE_NODISCARD types type() const noexcept override { return Float; }
    NEFORCE_NODISCARD const yaml_float* as_float() const noexcept override { return this; }

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

class NEFORCE_API yaml_string final : public yaml_value {
public:
    enum string_style {
        Plain,        
        SingleQuoted, 
        DoubleQuoted, 
        Literal,      
        Folded        
    };
 
private:
    string value;       
    string_style style; 
 
public:
    ~yaml_string() override = default;
 
    yaml_string(const yaml_string&) = default;
    yaml_string& operator=(const yaml_string&) = default;
    yaml_string(yaml_string&&) noexcept = default;
    yaml_string& operator=(yaml_string&&) noexcept = default;

    explicit yaml_string(string v, const string_style s = Plain) :
    value(_NEFORCE move(v)),
    style(s) {}
 
    NEFORCE_NODISCARD types type() const noexcept override { return String; }
    NEFORCE_NODISCARD const yaml_string* as_string() const noexcept override { return this; }

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

    NEFORCE_NODISCARD string_style get_style() const noexcept { return style; }
};

class NEFORCE_API yaml_timestamp final : public yaml_value {
private:
    datetime value; 
 
public:
    ~yaml_timestamp() override = default;
 
    yaml_timestamp(const yaml_timestamp&) = default;
    yaml_timestamp& operator=(const yaml_timestamp&) = default;
    yaml_timestamp(yaml_timestamp&&) noexcept = default;
    yaml_timestamp& operator=(yaml_timestamp&&) noexcept = default;

    explicit yaml_timestamp(const string_view v) {
        datetime dt;
        if (dt.try_parse_RFC3339(v) || dt.try_parse_ISO8601(v)) {
            value = dt;
        } else {
            NEFORCE_THROW_EXCEPTION(yaml_exception(("Invalid timestamp format: " + string(v)).data()));
        }
    }

    explicit yaml_timestamp(const datetime& dt) :
    value(dt) {}
 
    NEFORCE_NODISCARD types type() const noexcept override { return Timestamp; }
    NEFORCE_NODISCARD const yaml_timestamp* as_timestamp() const noexcept override { return this; }

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

    NEFORCE_NODISCARD string get_string_value() const { return value.to_RFC3339(); }
};

class NEFORCE_API yaml_sequence final : public yaml_value {
public:
    enum sequence_style {
        Block, 
        Flow   
    };
 
private:
    vector<shared_ptr<yaml_value>> elements; 
    sequence_style style;                    
 
public:
    ~yaml_sequence() override = default;

    explicit yaml_sequence(const sequence_style s = Block) :
    style(s) {}
 
    yaml_sequence(const yaml_sequence&) = delete;
    yaml_sequence& operator=(const yaml_sequence&) = delete;
    yaml_sequence(yaml_sequence&&) noexcept = default;
    yaml_sequence& operator=(yaml_sequence&&) noexcept = default;
 
    NEFORCE_NODISCARD types type() const noexcept override { return Sequence; }
    NEFORCE_NODISCARD const yaml_sequence* as_sequence() const noexcept override { return this; }

    void add_element(shared_ptr<yaml_value> value) { elements.emplace_back(_NEFORCE move(value)); }

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

    NEFORCE_NODISCARD yaml_value* get_element(const size_t index) 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<shared_ptr<yaml_value>>& get_elements() const noexcept { return elements; }

    NEFORCE_NODISCARD sequence_style get_style() const noexcept { return style; }

    void set_style(const sequence_style s) noexcept { style = s; }
};

class NEFORCE_API yaml_mapping final : public yaml_value {
public:
    enum mapping_style {
        Block, 
        Flow   
    };
 
private:
    unordered_map<string, shared_ptr<yaml_value>> members; 
    mapping_style style;                                   
 
public:
    ~yaml_mapping() override = default;

    explicit yaml_mapping(const mapping_style s = Block) :
    style(s) {}
 
    yaml_mapping(const yaml_mapping&) = delete;
    yaml_mapping& operator=(const yaml_mapping&) = delete;
    yaml_mapping(yaml_mapping&&) noexcept = default;
    yaml_mapping& operator=(yaml_mapping&&) noexcept = default;
 
    NEFORCE_NODISCARD types type() const noexcept override { return Mapping; }
    NEFORCE_NODISCARD const yaml_mapping* as_mapping() const noexcept override { return this; }

    void add_member(const string& key, shared_ptr<yaml_value> value) { members[key] = _NEFORCE move(value); }

    NEFORCE_NODISCARD const yaml_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 yaml_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, shared_ptr<yaml_value>>& get_members() const noexcept {
        return members;
    }

    NEFORCE_NODISCARD mapping_style get_style() const noexcept { return style; }

    void set_style(const mapping_style s) noexcept { style = s; }

    void merge_from(const yaml_mapping* other) {
        if (other == nullptr) {
            return;
        }
        for (const auto& pair: other->get_members()) {
            if (members.find(pair.first) == members.end()) {
                members[pair.first] = pair.second;
            }
        }
    }
};
 // YamlConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_YAML_YAML_VALUE_HPP__