env_value.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_ENV_ENV_VALUE_HPP__
#define NEFORCE_CORE_FILE_ENV_ENV_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 env_exception final : value_exception {
    explicit env_exception(const char* info = "ENV Operation Failed.", const char* type = static_type,
                           const int code = 0) noexcept :
    value_exception(info, type, code) {}
 
    explicit env_exception(const exception& e) :
    value_exception(e) {}
 
    ~env_exception() override = default;
    static constexpr auto static_type = "env_exception";
};
 // Exceptions


 
class env_variable;
 

class NEFORCE_API env_value : public istringify<env_value> {
public:
    enum types {
        Variable 
    };

    virtual ~env_value() = default;

    NEFORCE_NODISCARD virtual types type() const noexcept = 0;

    NEFORCE_NODISCARD virtual const env_variable* as_variable() const noexcept { return nullptr; }

    NEFORCE_NODISCARD bool is_variable() const noexcept { return type() == Variable; }

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD string to_document() const;
};
 

class NEFORCE_API env_variable final : public env_value {
public:
    enum quote_type {
        None,   
        Single, 
        Double  
    };
 
private:
    string value_;                 
    quote_type quote_type_ = None; 
    bool is_exported_ = false;     
 
public:
    explicit env_variable(string value, const quote_type quote = None, const bool exported = false) noexcept :
    value_(_NEFORCE move(value)),
    quote_type_(quote),
    is_exported_(exported) {}

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

    NEFORCE_NODISCARD const env_variable* as_variable() 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 quote_type get_quote_type() const noexcept { return quote_type_; }

    void set_quote_type(const quote_type quote) noexcept { quote_type_ = quote; }

    NEFORCE_NODISCARD bool is_exported() const noexcept { return is_exported_; }

    void set_exported(const bool exported) noexcept { is_exported_ = exported; }

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

    NEFORCE_NODISCARD int64_t get_int64(int64_t 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 env_document final : public istringify<env_document> {
private:
    unordered_map<string, unique_ptr<env_variable>> variables_; 
    vector<string> comments_;                                   
 
public:
    env_document() = default;
 
    env_document(const env_document&) = delete;
    env_document& operator=(const env_document&) = delete;

    env_document(env_document&& other) noexcept = default;

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

    void add_variable(const string& name, unique_ptr<env_variable> variable) {
        variables_[name] = _NEFORCE move(variable);
    }

    void set_variable(const string& name, string value, env_variable::quote_type quote = env_variable::None,
                      bool exported = false) {
        variables_[name] = make_unique<env_variable>(_NEFORCE move(value), quote, exported);
    }

    NEFORCE_NODISCARD const env_variable* get_variable(const string& name) const {
        const auto it = variables_.find(name);
        if (it != variables_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD env_variable* get_variable(const string& name) {
        const auto it = variables_.find(name);
        if (it != variables_.end()) {
            return it->second.get();
        }
        return nullptr;
    }

    NEFORCE_NODISCARD bool has_variable(const string& name) const { return variables_.find(name) != variables_.end(); }

    void remove_variable(const string& name) { variables_.erase(name); }

    NEFORCE_NODISCARD const unordered_map<string, unique_ptr<env_variable>>& get_variables() const noexcept {
        return variables_;
    }

    void add_comment(string comment) noexcept { comments_.emplace_back(move(comment)); }

    NEFORCE_NODISCARD const vector<string>& get_comments() const noexcept { return comments_; }

    NEFORCE_NODISCARD string get_string(const string& name, const string& default_value = "") const {
        const auto* var = get_variable(name);
        return var ? var->get_value() : default_value;
    }

    NEFORCE_NODISCARD int get_int(const string& name, const int default_value = 0) const {
        const auto* var = get_variable(name);
        return var ? var->get_int(default_value) : default_value;
    }

    NEFORCE_NODISCARD int64_t get_int64(const string& name, const int64_t default_value = 0) const {
        const auto* var = get_variable(name);
        return var ? var->get_int64(default_value) : default_value;
    }

    NEFORCE_NODISCARD double get_double(const string& name, const double default_value = 0.0) const {
        const auto* var = get_variable(name);
        return var ? var->get_double(default_value) : default_value;
    }

    NEFORCE_NODISCARD bool get_bool(const string& name, const bool default_value = false) const {
        const auto* var = get_variable(name);
        return var ? var->get_bool(default_value) : default_value;
    }

    NEFORCE_NODISCARD string to_string() const;
};
 // EnvConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_ENV_ENV_VALUE_HPP__