yaml_builder.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_YAML_YAML_BUILDER_HPP__
#define NEFORCE_CORE_FILE_YAML_YAML_BUILDER_HPP__

 
#include "NeForce/core/container/stack.hpp"
#include "NeForce/core/file/yaml/yaml_value.hpp"
#include "NeForce/core/functional/function.hpp"
NEFORCE_BEGIN_NAMESPACE__



class NEFORCE_API yaml_builder {
private:
    struct frame {
        enum context_type {
            mapping,
            sequence
        };
 
        context_type type = mapping;
        union {
            yaml_mapping* map_ptr = nullptr;
            yaml_sequence* seq_ptr;
        };
 
        frame() = default;
        frame(const context_type t, yaml_mapping* m) :
        type(t),
        map_ptr(m) {}
        frame(const context_type t, yaml_sequence* s) :
        type(t),
        seq_ptr(s) {}
 
        frame(const frame&) = default;
        frame& operator=(const frame&) = default;
        frame(frame&&) = default;
        frame& operator=(frame&&) = default;
        ~frame() = default;
    };
 
    stack<frame> contexts_;                                 
    shared_ptr<yaml_value> root_;                           
    string current_key_;                                    
    string pending_anchor_;                                 
    string pending_tag_;                                    
    unordered_map<string, shared_ptr<yaml_value>> anchors_; 
    vector<shared_ptr<yaml_value>> documents_;              

    void apply_pending_metadata(const shared_ptr<yaml_value>& value);

    template <typename T>
    yaml_builder& value_impl(shared_ptr<T> value) {
        apply_pending_metadata(value);
 
        if (contexts_.empty()) {
            NEFORCE_THROW_EXCEPTION(yaml_exception("Cannot add value: no active context"));
        }
 
        const auto& top = contexts_.top();
        if (top.type == frame::sequence) {
            top.seq_ptr->add_element(value);
        } else if (top.type == frame::mapping) {
            if (current_key_.empty()) {
                NEFORCE_THROW_EXCEPTION(yaml_exception("No key set for value in mapping"));
            }
            if (top.map_ptr->has_member(current_key_)) {
                NEFORCE_THROW_EXCEPTION(yaml_exception(("Duplicate key: " + current_key_).data()));
            }
            top.map_ptr->add_member(current_key_, value);
            current_key_.clear();
        }
        return *this;
    }
 
    template <typename Iterable>
    enable_if_t<is_maplike_v<Iterable>> value_iterable_impl(const Iterable& iterable) {
        begin_flow_mapping();
        for (const auto& pair: iterable) {
            this->key(pair.first).value(pair.second);
        }
        end_mapping();
        return;
    }
 
    template <typename Iterable>
    enable_if_t<!is_maplike_v<Iterable>> value_iterable_impl(const Iterable& iterable) {
        begin_sequence();
        for (const auto& element: iterable) {
            this->value(element);
        }
        end_sequence();
        return;
    }

    void add_to_parent_and_push(const shared_ptr<yaml_value>& container, frame f);
 
public:
    yaml_builder();
 
    yaml_builder(const yaml_builder&) = delete;
    yaml_builder& operator=(const yaml_builder&) = delete;

    yaml_builder(yaml_builder&& other) = default;

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

    yaml_builder& key(string key);

    yaml_builder& begin_mapping();

    yaml_builder& begin_block_mapping();

    yaml_builder& begin_flow_mapping();

    yaml_builder& end_mapping();

    yaml_builder& begin_sequence();

    yaml_builder& begin_block_sequence();

    yaml_builder& begin_flow_sequence();

    yaml_builder& end_sequence();

    yaml_builder& value(nullptr_t np) { return value_impl(make_shared<yaml_null>()); }

    yaml_builder& value(const bool v) { return value_impl(make_shared<yaml_boolean>(v)); }

    yaml_builder& value(const int64_t v) { return value_impl(make_shared<yaml_integer>(v)); }

    yaml_builder& value(const int v) { return value_impl(make_shared<yaml_integer>(static_cast<int64_t>(v))); }

    yaml_builder& value(const double v) { return value_impl(make_shared<yaml_float>(v)); }

    yaml_builder& value(string v) { return value_impl(make_shared<yaml_string>(_NEFORCE move(v), yaml_string::Plain)); }

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

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

    yaml_builder& value(shared_ptr<yaml_value> v) { return value_impl(_NEFORCE move(v)); }

    yaml_builder& value_datetime(const datetime& dt);

    yaml_builder& value_string(string v, yaml_string::string_style style);

    template <typename Iterable, enable_if_t<is_iterable_v<Iterable>, int> = 0>
    yaml_builder& value_iterable(const Iterable& iterable) {
        value_iterable_impl(iterable);
        return *this;
    }

    yaml_builder& value_mapping(const function<void(yaml_builder&)>& build_func);

    yaml_builder& value_block_mapping(const function<void(yaml_builder&)>& build_func);

    yaml_builder& value_flow_mapping(const function<void(yaml_builder&)>& build_func);

    yaml_builder& value_sequence(const function<void(yaml_builder&)>& build_func);

    yaml_builder& value_block_sequence(const function<void(yaml_builder&)>& build_func);

    yaml_builder& value_flow_sequence(const function<void(yaml_builder&)>& build_func);

    yaml_builder& anchor(string name);

    yaml_builder& tag(string t);

    yaml_builder& alias(const string& name);

    yaml_builder& begin_document();

    shared_ptr<yaml_value> build();

    vector<shared_ptr<yaml_value>> build_documents();
};
 // YamlConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_YAML_YAML_BUILDER_HPP__