type.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_REFLECT_METATYPE_HPP__
#define NEFORCE_CORE_REFLECT_METATYPE_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/reflect/enum.hpp"
#include "NeForce/core/reflect/function.hpp"
#include "NeForce/core/reflect/property.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_REFLECT__
 
class registry;


enum class container_kind : uint8_t {
    none,        
    sequential,  
    associative, 
};

class meta_type {
public:
    using constructor_func = _NEFORCE function<meta_any(const vector<meta_any>&)>; 
    using clone_func = _NEFORCE function<meta_any(const void*)>;                   
    using container_size_func = _NEFORCE function<size_t(const void*)>;            
    using container_get_func = _NEFORCE function<meta_any(const void*, size_t)>;   
    using container_insert_func = _NEFORCE function<void(void*, const meta_any&)>; 
    using container_insert_kv_func = _NEFORCE function<void(void*, const meta_any&, const meta_any&)>; 
 
private:
    reflect::type_id type_id_;                                    
    string_view name_;                                            
    size_t size_;                                                 
    string table_name_;                                           
    constructor_func constructor_;                                
    clone_func cloner_;                                           
    vector<meta_type*> base_types_;                               
    vector<string> pending_base_names_;                           
    unordered_map<string, unique_ptr<meta_property>> properties_; 
    unordered_map<string, unique_ptr<meta_function>> functions_;  
    vector<string> signal_names_;                                 
    unique_ptr<meta_enum> enum_info_;                             
    container_kind container_kind_ = container_kind::none;        
    reflect::type_id element_type_id_ = 0;                        
    reflect::type_id key_type_id_ = 0;                            
    reflect::type_id mapped_type_id_ = 0;                         
    container_size_func container_size_;                          
    container_get_func container_get_;                            
    container_insert_func container_insert_;                      
    container_insert_kv_func container_insert_kv_;                
 
    void collect_properties(vector<pair<string, const meta_property*>>& result,
                            vector<reflect::type_id>* visited = nullptr) const {
        vector<reflect::type_id> local_visited;
        if (visited == nullptr) {
            visited = &local_visited;
        }
 
        if (find(visited->begin(), visited->end(), type_id_) != visited->end()) {
            return;
        }
        visited->push_back(type_id_);
 
        for (const auto* base: base_types_) {
            if (base != nullptr) {
                base->collect_properties(result, visited);
            }
        }
 
        for (const auto& property: properties_) {
            const auto& name = property.first;
            const auto& prop = property.second;
            result.emplace_back(name, prop.get());
        }
    }
 
    void collect_functions(vector<pair<string, const meta_function*>>& result,
                           vector<reflect::type_id>* visited = nullptr) const {
        vector<reflect::type_id> local_visited;
        if (visited == nullptr) {
            visited = &local_visited;
        }
 
        if (find(visited->begin(), visited->end(), type_id_) != visited->end()) {
            return;
        }
        visited->push_back(type_id_);
 
        for (const auto* base: base_types_) {
            if (base != nullptr) {
                base->collect_functions(result, visited);
            }
        }
 
        for (const auto& f: functions_) {
            const auto& name = f.first;
            const auto& func = f.second;
            result.emplace_back(name, func.get());
        }
    }
 
public:
    meta_type(string_view name, reflect::type_id id, size_t size) :
    type_id_(id),
    name_(name),
    size_(size) {}

    NEFORCE_NODISCARD reflect::type_id type_id() const noexcept { return type_id_; }

    NEFORCE_NODISCARD string_view name() const noexcept { return name_; }

    NEFORCE_NODISCARD string_view table_name() const noexcept { return table_name_.view(); }

    meta_type& set_table_name(string_view table) {
        table_name_ = table;
        return *this;
    }

    NEFORCE_NODISCARD size_t size() const noexcept { return size_; }

    NEFORCE_NODISCARD const vector<meta_type*>& base_types() const { return base_types_; }

    meta_type& base_type(meta_type* base) {
        if (base != nullptr) {
            base_types_.push_back(base);
        }
        return *this;
    }

    meta_type& base_type(string_view base_name) {
        pending_base_names_.push_back(base_name);
        return *this;
    }

    NEFORCE_NODISCARD bool is_derived_from(reflect::type_id base_id) const {
        if (type_id_ == base_id) {
            return true;
        }
        for (const auto* base: base_types_) {
            if (base != nullptr && base->is_derived_from(base_id)) {
                return true;
            }
        }
        return false;
    }

    NEFORCE_NODISCARD bool is_derived_from(string_view base_name) const {
        for (const auto* base: base_types_) {
            if (base != nullptr && (base->name() == base_name || base->is_derived_from(base_name))) {
                return true;
            }
        }
        return false;
    }

    meta_type& property(string_view name, reflect::type_id prop_type_id, meta_property::getter getter,
                        meta_property::setter setter, const uint16_t attrs = PROP_NONE) {
        auto prop = make_unique<meta_property>(name, prop_type_id, move(getter), move(setter), attrs);
        properties_.emplace(name, move(prop));
        return *this;
    }

    meta_function* function(string_view name, meta_function::invoker invoker) {
        const auto it = functions_.emplace(name, make_unique<meta_function>(name, move(invoker))).first;
        return it->second.get();
    }

    meta_type& constructor(constructor_func ctor) {
        constructor_ = move(ctor);
        return *this;
    }

    meta_type& cloner(clone_func cloner) {
        cloner_ = move(cloner);
        return *this;
    }

    NEFORCE_NODISCARD meta_any clone(const void* src) const { return cloner_ ? cloner_(src) : meta_any{}; }

    NEFORCE_NODISCARD const meta_enum* enum_info() const noexcept { return enum_info_.get(); }

    NEFORCE_NODISCARD bool is_enum() const noexcept { return !!enum_info_; }

    meta_type& enum_info(unique_ptr<meta_enum> info) {
        enum_info_ = move(info);
        return *this;
    }

    NEFORCE_NODISCARD container_kind container() const noexcept { return container_kind_; }

    meta_type& container(container_kind kind) {
        container_kind_ = kind;
        return *this;
    }

    NEFORCE_NODISCARD reflect::type_id element_type_id() const noexcept { return element_type_id_; }

    meta_type& element_type_id(reflect::type_id id) {
        element_type_id_ = id;
        return *this;
    }

    NEFORCE_NODISCARD reflect::type_id key_type_id() const noexcept { return key_type_id_; }

    meta_type& key_type_id(reflect::type_id id) {
        key_type_id_ = id;
        return *this;
    }

    NEFORCE_NODISCARD reflect::type_id mapped_type_id() const noexcept { return mapped_type_id_; }

    meta_type& mapped_type_id(reflect::type_id id) {
        mapped_type_id_ = id;
        return *this;
    }

    meta_type& container_size(container_size_func func) {
        container_size_ = move(func);
        return *this;
    }

    NEFORCE_NODISCARD size_t container_element_count(const void* container_ptr) const {
        return container_size_ ? container_size_(container_ptr) : 0;
    }

    meta_type& container_get(container_get_func func) {
        container_get_ = move(func);
        return *this;
    }

    NEFORCE_NODISCARD meta_any container_element_at(const void* container_ptr, size_t index) const {
        return container_get_ ? container_get_(container_ptr, index) : meta_any{};
    }

    meta_type& container_insert(container_insert_func func) {
        container_insert_ = move(func);
        return *this;
    }

    void container_push_back(void* container_ptr, const meta_any& value) const {
        if (container_insert_) {
            container_insert_(container_ptr, value);
        }
    }

    meta_type& container_insert_kv(container_insert_kv_func func) {
        container_insert_kv_ = move(func);
        return *this;
    }

    void container_insert_pair(void* container_ptr, const meta_any& key, const meta_any& value) const {
        if (container_insert_kv_) {
            container_insert_kv_(container_ptr, key, value);
        }
    }

    NEFORCE_NODISCARD bool is_container() const noexcept { return container_kind_ != container_kind::none; }

    NEFORCE_NODISCARD const meta_property* get_property(string_view name) const {
        const auto it = properties_.find(name);
        if (it != properties_.end()) {
            return it->second.get();
        }
 
        for (const auto* base: base_types_) {
            if (base != nullptr) {
                if (const auto* prop = base->get_property(name)) {
                    return prop;
                }
            }
        }
        return nullptr;
    }

    NEFORCE_NODISCARD const meta_function* get_function(string_view name) const {
        const auto it = functions_.find(name);
        if (it != functions_.end()) {
            return it->second.get();
        }
 
        for (const auto* base: base_types_) {
            if (base != nullptr) {
                if (const auto* func = base->get_function(name)) {
                    return func;
                }
            }
        }
        return nullptr;
    }

    meta_type& register_signal(string_view name) {
        signal_names_.push_back(name);
        return *this;
    }

    NEFORCE_NODISCARD const vector<string>& signal_names() const noexcept { return signal_names_; }

    void add_property(string_view name, unique_ptr<meta_property> prop) { properties_.emplace(name, move(prop)); }

    NEFORCE_NODISCARD meta_any create() const { return constructor_ ? constructor_({}) : meta_any{}; }

    NEFORCE_NODISCARD meta_any create(const vector<meta_any>& args) const {
        return constructor_ ? constructor_(args) : meta_any{};
    }

    NEFORCE_NODISCARD const auto& properties() const { return properties_; }

    NEFORCE_NODISCARD const auto& functions() const { return functions_; }

    NEFORCE_NODISCARD vector<pair<string, const meta_property*>> all_properties() const {
        vector<pair<string, const meta_property*>> result;
        collect_properties(result);
        return result;
    }

    NEFORCE_NODISCARD vector<pair<string, const meta_function*>> all_functions() const {
        vector<pair<string, const meta_function*>> result;
        collect_functions(result);
        return result;
    }

    void resolve_bases(registry* registry);

    void resolve_bases_unlocked(registry* registry);

    NEFORCE_NODISCARD bool has_pending_bases() const noexcept { return !pending_base_names_.empty(); }
};
 // Reflection
 
NEFORCE_END_REFLECT__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_REFLECT_METATYPE_HPP__