toml_builder.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_TOML_BUILDER_HPP__
#define NEFORCE_CORE_FILE_TOML_BUILDER_HPP__

 
#include "NeForce/core/container/stack.hpp"
#include "NeForce/core/file/toml/toml_value.hpp"
#include "NeForce/core/functional/function.hpp"
NEFORCE_BEGIN_NAMESPACE__



class NEFORCE_API toml_builder {
private:
    enum range_type {
        table,        
        inline_table, 
        array         
    };

    struct frame {
        range_type type = table; 
        union {
            toml_table* table_ptr = nullptr; 
            toml_array* array_ptr;           
        };
 
        frame() = default;
        frame(const range_type t, toml_table* tbl) :
        type(t),
        table_ptr(tbl) {}
        frame(const range_type t, toml_array* arr) :
        type(t),
        array_ptr(arr) {}
 
        frame(const frame&) = default;
        frame& operator=(const frame&) = default;
        frame(frame&&) = default;
        frame& operator=(frame&&) = default;
        ~frame() = default;
    };
 
    stack<frame> contexts_;       
    unique_ptr<toml_table> root_; 
    string current_key_;          
 
private:
    template <typename T>
    toml_builder& value_impl(unique_ptr<T> value) {
        if (contexts_.empty()) {
            NEFORCE_THROW_EXCEPTION(toml_exception("Cannot add value to root (root must be a table)"));
        }
 
        const auto& top = contexts_.top();
        if (top.type == array) {
            top.array_ptr->add_element(_NEFORCE move(value));
        } else if (top.type == table || top.type == inline_table) {
            if (current_key_.empty()) {
                NEFORCE_THROW_EXCEPTION(toml_exception("No key set for value in table"));
            }
            if (top.table_ptr->has_member(current_key_)) {
                NEFORCE_THROW_EXCEPTION(toml_exception(("Duplicate key: " + current_key_).data()));
            }
            top.table_ptr->add_member(current_key_, _NEFORCE move(value));
            current_key_.clear();
        }
        return *this;
    }

    template <typename Iterable>
    enable_if_t<is_iterable_v<Iterable>, toml_builder&> value_iterable_dispatch(const Iterable& iterable) {
        return this->value_iterable_impl(iterable);
    }

    template <typename Map>
    enable_if_t<is_maplike_v<Map>, toml_builder&> value_iterable_impl(const Map& maplike) {
        begin_inline_table();
        for (const auto& pair: maplike) {
            this->key(pair.first).value(pair.second);
        }
        end_inline_table();
        return *this;
    }

    template <typename Iterable>
    enable_if_t<!is_maplike_v<Iterable>, toml_builder&> value_iterable_impl(const Iterable& iterable) {
        begin_array();
        for (const auto& element: iterable) {
            this->value(element);
        }
        end_array();
        return *this;
    }

    toml_table* get_or_create_table_path(const vector<string>& path) const;

    toml_array* get_or_create_array_for_array_table(const vector<string>& path) const;
 
public:
    toml_builder();
 
    toml_builder(const toml_builder&) = delete;
    toml_builder& operator=(const toml_builder&) = delete;

    toml_builder(toml_builder&& other) = default;

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

    toml_builder& key(string key);

    toml_builder& begin_table(const string& name);

    toml_builder& begin_table(const vector<string>& path);

    toml_builder& end_table();

    toml_builder& begin_inline_table();

    toml_builder& end_inline_table();

    toml_builder& begin_array();

    toml_builder& end_array();

    toml_builder& begin_array_table(const string& name);

    toml_builder& begin_array_table(const vector<string>& path);

    toml_builder& end_array_table();

    toml_builder& value(nullptr_t np) { return value_impl(make_unique<toml_boolean>(false)); }

    toml_builder& value(const bool value) { return value_impl(make_unique<toml_boolean>(value)); }

    toml_builder& value(const int64_t value) { return value_impl(make_unique<toml_integer>(value)); }

    toml_builder& value(const int value) { return this->value(static_cast<int64_t>(value)); }

    toml_builder& value(const double value) { return value_impl(make_unique<toml_float>(value)); }

    toml_builder& value(string value) {
        return value_impl(make_unique<toml_string>(_NEFORCE move(value), toml_string::Basic));
    }

    toml_builder& value(const char* value) { return this->value(string(value)); }

    toml_builder& value(const string_view value) { return this->value(string(value)); }

    toml_builder& value(unique_ptr<toml_value> value) { return value_impl(_NEFORCE move(value)); }

    toml_builder& value_string(string value, toml_string::string_type type) {
        return value_impl(make_unique<toml_string>(_NEFORCE move(value), type));
    }

    toml_builder& value_datetime(const string_view value, toml_datetime::datetime_type type) {
        return value_impl(make_unique<toml_datetime>(value, type));
    }

    template <typename Iterable>
    toml_builder& value(const Iterable& iterable) {
        return this->value_iterable_dispatch(iterable);
    }

    toml_builder& value_table(const function<void(toml_builder&)>& build_func);

    toml_builder& value_inline_table(const function<void(toml_builder&)>& build_func);

    toml_builder& value_array(const function<void(toml_builder&)>& build_func);

    unique_ptr<toml_table> build();
};
 // TomlConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_TOML_BUILDER_HPP__