registry.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_REFLECT_REGISTRY_HPP__
#define NEFORCE_CORE_REFLECT_REGISTRY_HPP__

 
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/reflect/type.hpp"
NEFORCE_BEGIN_NAMESPACE__
 
class signal_base;
 
NEFORCE_BEGIN_REFLECT__


class NEFORCE_API registry {
private:
    mutex mutex_;                                          
    unordered_map<type_id, unique_ptr<meta_type>> types_;  
    unordered_map<type_id, type_id> name_hash_to_type_id_; 
 
    registry() = default;
 
public:
    static registry& instance();

    template <typename T>
    meta_type& register_type(string_view name) {
        type_id id = type_id_for<T>();
 
        lock<mutex> lk(mutex_);
        auto it = types_.find(id);
        if (it != types_.end()) {
            return *it->second;
        }
 
        auto name_hash = name.to_hash();
        auto new_it = types_.emplace(id, make_unique<meta_type>(name, id, sizeof(T))).first;
        name_hash_to_type_id_.emplace(name_hash, id);
        return *new_it->second;
    }

    meta_type* find_unlocked(string_view name) {
        auto name_hash = name.to_hash();
        auto map_it = name_hash_to_type_id_.find(name_hash);
        if (map_it == name_hash_to_type_id_.end()) {
            return nullptr;
        }
        auto it = types_.find(map_it->second);
        return it != types_.end() ? it->second.get() : nullptr;
    }

    meta_type* find(string_view name) {
        lock<mutex> lock(mutex_);
        return find_unlocked(name);
    }

    meta_type* find(type_id id) {
        lock<mutex> lock(mutex_);
        const auto it = types_.find(id);
        return it != types_.end() ? it->second.get() : nullptr;
    }

    template <typename Func>
    void for_each(Func&& func) {
        lock<mutex> lock(mutex_);
        for (auto& type: types_) {
            func(*type.second);
        }
    }

    void resolve_all_bases() {
        lock<mutex> lk(mutex_);
        for (const auto& type: types_) {
            type.second->resolve_bases_unlocked(this);
        }
    }

    static bool dynamic_connect(void* sender_obj, string_view sender_type, string_view signal_name,
                                size_t signal_offset, void* receiver_obj, string_view receiver_type,
                                string_view slot_name) {
        const auto* s_meta = instance().find(sender_type);
        const auto* r_meta = instance().find(receiver_type);
        if ((s_meta == nullptr) || (r_meta == nullptr)) {
            return false;
        }
 
        const auto* slot = r_meta->get_function(slot_name);
        if (slot == nullptr) {
            return false;
        }
 
        auto* sig_base = reinterpret_cast<signal_base*>(static_cast<char*>(sender_obj) + signal_offset);
        if (sig_base == nullptr) {
            return false;
        }
 
        return connect_signal_to_slot(sig_base, slot, receiver_obj);
    }

    static bool connect_signal_to_slot(signal_base* sig, const meta_function* slot, void* receiver);
};
 // Reflection
 
NEFORCE_END_REFLECT__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_REFLECT_REGISTRY_HPP__