ini_value.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_INI_INI_VALUE_HPP__
#define NEFORCE_CORE_FILE_INI_INI_VALUE_HPP__

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


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


 
class ini_value;
class ini_section;
class ini_property;
 

class NEFORCE_API ini_value : public istringify<ini_value> {
public:
    enum types {
        Section, 
        Property 
    };

    virtual ~ini_value() = default;

    NEFORCE_NODISCARD virtual types type() const noexcept = 0;

    NEFORCE_NODISCARD virtual const ini_section* as_section() const noexcept { return nullptr; }

    NEFORCE_NODISCARD virtual const ini_property* as_property() const noexcept { return nullptr; }

    NEFORCE_NODISCARD bool is_section() const noexcept { return type() == Section; }

    NEFORCE_NODISCARD bool is_property() const noexcept { return type() == Property; }

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_document() const;
};
 

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

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

    NEFORCE_NODISCARD const ini_property* as_property() const noexcept override { return this; }

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

    void set_value(string value) noexcept { value_ = _NEFORCE move(value); }

    NEFORCE_NODISCARD int get_int(int default_value = 0) const noexcept;

    NEFORCE_NODISCARD double get_double(double default_value = 0.0) const noexcept;

    NEFORCE_NODISCARD bool get_bool(bool default_value = false) const noexcept;
};
 

class NEFORCE_API ini_section final : public ini_value {
private:
    unordered_map<string, unique_ptr<ini_property>> properties_; 
    string name_{};                                              
 
public:
    ini_section() = default;

    explicit ini_section(string name) noexcept :
    name_(_NEFORCE move(name)) {}
 
    ini_section(const ini_section&) = delete;
    ini_section& operator=(const ini_section&) = delete;

    ini_section(ini_section&& other) noexcept = default;

    ini_section& operator=(ini_section&& other) noexcept = default;

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

    NEFORCE_NODISCARD const ini_section* as_section() const noexcept override { return this; }

    NEFORCE_NODISCARD const string& get_name() const noexcept { return name_; }

    void set_name(string name) noexcept { name_ = _NEFORCE move(name); }

    void add_property(const string& key, unique_ptr<ini_property> property) {
        properties_[key] = _NEFORCE move(property);
    }

    void set_property(const string& key, string value) { properties_[key] = make_unique<ini_property>(move(value)); }

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

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

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

    NEFORCE_NODISCARD const unordered_map<string, unique_ptr<ini_property>>& get_properties() const noexcept {
        return properties_;
    }

    NEFORCE_NODISCARD string get_string(const string& key, const string& default_value = "") const {
        const ini_property* prop = get_property(key);
        return prop ? prop->get_value() : default_value;
    }

    NEFORCE_NODISCARD int get_int(const string& key, int default_value = 0) const {
        const ini_property* prop = get_property(key);
        return prop ? prop->get_int(default_value) : default_value;
    }

    NEFORCE_NODISCARD double get_double(const string& key, double default_value = 0.0) const {
        const ini_property* prop = get_property(key);
        return prop ? prop->get_double(default_value) : default_value;
    }

    NEFORCE_NODISCARD bool get_bool(const string& key, bool default_value = false) const {
        const ini_property* prop = get_property(key);
        return prop ? prop->get_bool(default_value) : default_value;
    }
};
 

class NEFORCE_API ini_document final : public istringify<ini_document> {
private:
    unordered_map<string, unique_ptr<ini_section>> sections_; 
    unique_ptr<ini_section> global_section_;                  
 
public:
    ini_document() :
    global_section_(make_unique<ini_section>("")) {}
 
    ini_document(const ini_document&) = delete;
    ini_document& operator=(const ini_document&) = delete;

    ini_document(ini_document&& other) noexcept = default;

    ini_document& operator=(ini_document&& other) noexcept = default;

    void add_section(const string& name, unique_ptr<ini_section> section) {
        if (name.empty()) {
            global_section_ = _NEFORCE move(section);
        } else {
            sections_[name] = _NEFORCE move(section);
        }
    }

    NEFORCE_NODISCARD const ini_section* get_section(const string& name) const {
        if (name.empty()) {
            return global_section_.get();
        }
        const auto it = sections_.find(name);
        if (it != sections_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD ini_section* get_section(const string& name) {
        if (name.empty()) {
            return global_section_.get();
        }
        const auto it = sections_.find(name);
        if (it != sections_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD bool has_section(const string& name) const {
        if (name.empty()) {
            return global_section_ != nullptr;
        }
        return sections_.find(name) != sections_.end();
    }

    NEFORCE_NODISCARD const unordered_map<string, unique_ptr<ini_section>>& get_sections() const noexcept {
        return sections_;
    }

    NEFORCE_NODISCARD const ini_section* get_global_section() const noexcept { return global_section_.get(); }

    NEFORCE_NODISCARD ini_section* get_global_section() noexcept { return global_section_.get(); }

    NEFORCE_NODISCARD string get_string(const string& section, const string& key,
                                        const string& default_value = "") const {
        const ini_section* sec = get_section(section);
        return sec ? sec->get_string(key, default_value) : default_value;
    }

    NEFORCE_NODISCARD int get_int(const string& section, const string& key, int default_value = 0) const {
        const ini_section* sec = get_section(section);
        return sec ? sec->get_int(key, default_value) : default_value;
    }

    NEFORCE_NODISCARD double get_double(const string& section, const string& key, double default_value = 0.0) const {
        const ini_section* sec = get_section(section);
        return sec ? sec->get_double(key, default_value) : default_value;
    }

    NEFORCE_NODISCARD bool get_bool(const string& section, const string& key, bool default_value = false) const {
        const ini_section* sec = get_section(section);
        return sec ? sec->get_bool(key, default_value) : default_value;
    }

    NEFORCE_NODISCARD string to_string() const;
};
 // IniConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_INI_INI_VALUE_HPP__