json_builder.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_JSON_JSON_BUILDER_HPP__
#define NEFORCE_CORE_FILE_JSON_JSON_BUILDER_HPP__

 
#include "NeForce/core/container/stack.hpp"
#include "NeForce/core/file/json/json_value.hpp"
#include "NeForce/core/functional/function.hpp"
NEFORCE_BEGIN_NAMESPACE__



class NEFORCE_API json_builder {
private:
    enum range_type {
        object,
        array
    };

    struct frame {
        range_type type = object; 
        union {
            json_object* object_ptr = nullptr; 
            json_array* array_ptr;             
        };
 
        frame() = default;
        frame(const range_type t, json_object* obj) :
        type(t),
        object_ptr(obj) {}
        frame(const range_type t, json_array* arr) :
        type(t),
        array_ptr(arr) {}
 
        frame(const frame&) = default;
        frame& operator=(const frame&) = default;
        frame(frame&&) noexcept = default;
        frame& operator=(frame&&) noexcept = default;
        ~frame() = default;
    };
 
    stack<frame> contexts_;       
    unique_ptr<json_value> root_; 
    string current_key_;          
 
private:
    template <typename T>
    json_builder& value_impl(unique_ptr<T> value) {
        if (contexts_.empty()) {
            if (root_) {
                NEFORCE_THROW_EXCEPTION(json_exception("Multiple root values not allowed"));
            }
            root_ = _NEFORCE move(value);
        } else {
            const auto& top = contexts_.top();
            if (top.type == array) {
                top.array_ptr->add_element(_NEFORCE move(value));
            } else if (top.type == object) {
                if (current_key_.empty()) {
                    NEFORCE_THROW_EXCEPTION(json_exception("No key set for value in object"));
                }
                top.object_ptr->add_member(current_key_, _NEFORCE move(value));
                current_key_.clear();
            }
        }
        return *this;
    }

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

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

    template <typename Iterable>
    enable_if_t<!is_maplike_v<Iterable>, json_builder&> value_iterable_impl(const Iterable& iterable) {
        begin_array();
        for (const auto& element: iterable) {
            this->value(element);
        }
        end_array();
        return *this;
    }
 
public:
    json_builder() = default;
    ~json_builder() = default;
 
    json_builder(const json_builder&) = delete;
    json_builder& operator=(const json_builder&) = delete;
 
    json_builder(json_builder&& other) noexcept = default;
    json_builder& operator=(json_builder&& other) noexcept = default;

    json_builder& begin_object();

    json_builder& begin_array();

    json_builder& end_object();

    json_builder& end_array();

    json_builder& key(const string& key);

    json_builder& value(nullptr_t np) { return value_impl(make_unique<json_null>()); }

    json_builder& value(const string& value) { return value_impl(make_unique<json_string>(value)); }

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

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

    json_builder& value(const double value) { return value_impl(make_unique<json_number>(value)); }

    json_builder& value(const int value) { return value_impl(make_unique<json_number>(static_cast<double>(value))); }

    json_builder& value(const bool value) { return value_impl(make_unique<json_bool>(value)); }

    json_builder& value(unique_ptr<json_value>&& value) { return value_impl(_NEFORCE move(value)); }

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

    json_builder& value_object(const function<void(json_builder&)>& build_func);

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

    unique_ptr<json_value> build();
};
 // JsonConfig
 // ConfigFormat
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_JSON_JSON_BUILDER_HPP__