reflect.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_REFLECT_REFLECT_HPP__
#define NEFORCE_CORE_REFLECT_REFLECT_HPP__

 
#include "NeForce/core/reflect/registry.hpp"
#include "NeForce/core/reflect/function.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_REFLECT__


template <typename T>
class type_builder {
private:
    meta_type& meta_;
 
    template <typename... Args, size_t... Is>
    static meta_any create_with_args(const vector<meta_any>& args, index_sequence<Is...> /*unused*/) {
        return meta_any(T(args[Is].template convert<Args>()...));
    }
 
public:
    explicit type_builder(string_view name) :
    meta_(registry::instance().register_type<T>(name)) {}

    template <typename Base>
    type_builder& base() {
        meta_.base_type(&registry::instance().register_type<Base>(type_name_v<Base>));
        return *this;
    }

    type_builder& base(string_view base_name) {
        meta_.base_type(base_name);
        return *this;
    }

    template <typename U>
    type_builder& property(string_view name, U T::* member, const uint16_t attrs = PROP_NONE) {
        meta_property::getter getter = [member](const void* obj) -> meta_any {
            auto* instance = static_cast<const T*>(obj);
            return meta_any(instance->*member);
        };
 
        meta_property::setter setter = [member](void* obj, const meta_any& value) {
            auto* instance = static_cast<T*>(obj);
            auto* val = value.cast<U>();
            if (val) {
                instance->*member = *val;
            }
        };
 
        meta_.property(name, type_id_for<U>(), move(getter), move(setter), attrs);
        return *this;
    }

    template <typename U>
    type_builder& property(string_view name, U T::* member, const uint16_t attrs, string_view notify_signal) {
        this->template property<U>(name, member, attrs);
        const auto* prop = meta_.get_property(name);
        if (prop) {
            const_cast<meta_property*>(prop)->set_notify_signal(notify_signal);
        }
        return *this;
    }

    template <typename U>
    type_builder& readonly_property(string_view name, U T::* member) {
        return this->template property<U>(name, member, PROP_READ_ONLY);
    }

    template <typename Ret, typename... Args>
    type_builder& function(string_view name, Ret (T::*func)(Args...)) {
        auto invoker = _NEFORCE inner::make_member_invoker(func);
        auto* meta_func = meta_.function(name, _NEFORCE move(invoker));
        if (meta_func) {
            meta_func->set_arg_hints(sizeof...(Args), sizeof...(Args));
        }
        return *this;
    }

    template <typename Ret, typename... Args>
    type_builder& function(string_view name, Ret (T::*func)(Args...) const) {
        auto invoker = _NEFORCE inner::make_const_member_invoker(func);
        auto* meta_func = meta_.function(name, _NEFORCE move(invoker));
        if (meta_func) {
            meta_func->set_arg_hints(sizeof...(Args), sizeof...(Args));
        }
        return *this;
    }

    template <typename Ret, typename... Args>
    type_builder& static_function(string_view name, Ret (*func)(Args...)) {
        auto invoker = _NEFORCE inner::make_static_invoker(func);
        auto* meta_func = meta_.function(name, _NEFORCE move(invoker));
        meta_func->set_arg_hints(sizeof...(Args), sizeof...(Args));
        return *this;
    }

    type_builder& constructor() {
        static_assert(is_default_constructible_v<T>, "Constructor must be default constructible");
        meta_.constructor([](const vector<meta_any>&) -> meta_any {
            meta_any result;
            result.emplace<T>();
            return result;
        });
        return *this;
    }

    template <typename... Args>
    type_builder& constructor() {
        static_assert(is_constructible_v<T, Args...>, "Constructor must be constructible from Args");
        meta_.constructor([](const vector<meta_any>& args) -> meta_any {
            if (args.size() != sizeof...(Args)) {
                NEFORCE_THROW_EXCEPTION(value_exception("Constructor argument count mismatch"));
            }
            return type_builder::create_with_args<Args...>(args, make_index_sequence<sizeof...(Args)>{});
        });
        return *this;
    }

    type_builder& table_name(string_view table) {
        meta_.set_table_name(table);
        return *this;
    }
 
    type_builder& signal(string_view name) {
        meta_.register_signal(name);
        return *this;
    }

    type_builder& enable_clone() {
        static_assert(is_copy_constructible_v<T>, "Clone requires copy constructible type");
        meta_.cloner([](const void* src) -> meta_any { return meta_any(*static_cast<const T*>(src)); });
        return *this;
    }

    template <typename ElementType>
    type_builder& as_sequential_container() {
        meta_.container(container_kind::sequential);
        meta_.element_type_id(type_id_for<ElementType>());
 
        meta_.container_size([](const void* c) -> size_t { return static_cast<const T*>(c)->size(); });
 
        meta_.container_get([](const void* c, size_t index) -> meta_any {
            const auto* container = static_cast<const T*>(c);
            auto it = container->begin();
            for (size_t i = 0; i < index; ++i) {
                ++it;
            }
            return meta_any(*it);
        });
 
        meta_.container_insert([](void* c, const meta_any& val) {
            auto* container = static_cast<T*>(c);
            if (auto* ptr = val.cast<ElementType>()) {
                container->push_back(*ptr);
            }
        });
 
        return *this;
    }

    template <typename KeyType, typename MappedType>
    type_builder& as_associative_container() {
        meta_.container(container_kind::associative);
        meta_.key_type_id(type_id_for<KeyType>());
        meta_.mapped_type_id(type_id_for<MappedType>());
 
        meta_.container_size([](const void* c) -> size_t { return static_cast<const T*>(c)->size(); });
 
        meta_.container_get([](const void* c, size_t index) -> meta_any {
            const auto* container = static_cast<const T*>(c);
            auto it = container->begin();
            for (size_t i = 0; i < index; ++i) {
                ++it;
            }
            return meta_any(it->first);
        });
 
        meta_.container_insert_kv([](void* c, const meta_any& key, const meta_any& val) {
            auto* container = static_cast<T*>(c);
            auto* kptr = key.cast<KeyType>();
            auto* vptr = val.cast<MappedType>();
            if (kptr && vptr) {
                container->insert({*kptr, *vptr});
            }
        });
 
        return *this;
    }

    NEFORCE_NODISCARD meta_type& meta() noexcept { return meta_; }

    NEFORCE_NODISCARD const meta_type& meta() const noexcept { return meta_; }
};

template <typename T, enable_if_t<is_class_v<T>, int> = 0>
type_builder<T> reflect(string_view name) {
    return type_builder<T>(name);
}
 

#define NEFORCE_REFLECT_REGISTER(Class) static auto _neforce_reflect_##Class = _NEFORCE reflect::reflect<Class>(#Class)

#define NEFORCE_REFLECT_REGISTER_DERIVED(Class, Base) \
    static auto _neforce_reflect_##Class = _NEFORCE reflect::reflect<Class>(#Class).template base<Base>()

#define NEFORCE_REFLECT_RESOLVE_BASES() _NEFORCE reflect::registry::instance().resolve_all_bases()
 // Reflection
 
NEFORCE_END_REFLECT__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_REFLECT_REFLECT_HPP__