EnTT: 运行时反射系统 Runtime reflection system

entt::meta_factory<my_type>{}.type("reflected_type"_hs);

entt::meta_factory<my_type>{}.type(42u);

entt::meta_factory<my_type> factory{};

entt::meta_factory<my_type>{}.type("reflected_type"_hs);

entt::meta_factory<my_type>{}
    .ctor<int, char>()  // 定义 (int, char) 类型的构造函数
    .ctor<&factory>();  // 将自由函数视为构造函数

entt::meta_factory<my_type>{}.dtor<&destroy>();

entt::meta_factory<my_type>{}
    .data<&my_type::static_variable>("static"_hs)  // 静态变量
    .data<&my_type::data_member>("member"_hs)      // 成员变量
    .data<&global_variable>("global"_hs);          // 全局变量

int get_data();
void set_data(int value);
 
// 注册为反射系统中的数据成员
entt::meta_factory<my_type>{}.data<&set_data, &get_data>("data"_hs);

entt::meta_factory<my_type>{}.data<nullptr, &my_type::data_member>("member"_hs);

entt::meta_factory<my_type>{}
    .data<
        entt::value_list<&from_int, &from_string>, 
        &my_type::data_member
    >("member"_hs);

entt::meta_factory<my_type>{}
    .func<&my_type::static_function>("static"_hs)  // 静态函数
    .func<&my_type::member_function>("member"_hs)  // 成员函数
    .func<&free_function>("free"_hs);              // 自由函数

entt::meta_factory<derived_type>{}.base<base_type>();

entt::meta_factory<double>{}.conv<int>();

entt::meta_any empty{};
entt::meta_any other{std::in_place_type<void>};
 
std::cout << empty ? "Valid" : "Empty";  // 输出：Empty
std::cout << other ? "Valid" : "Empty";  // 输出：Valid

entt::meta_any instance = 42;  // 存储一个整数

int value = 42;
entt::meta_any ref = std::forward_as_meta(value);  // 引用

entt::meta_any ptr{std::in_place, new int{42}};

// direct access to a reflected type
auto by_type = entt::resolve<my_type>();
 
// look up a reflected type by identifier
auto by_id = entt::resolve("reflected_type"_hs);
 
// look up a reflected type by type info
auto by_type_id = entt::resolve(entt::type_id<my_type>());

for (auto &&[id, type] : entt::resolve()) {
    // 处理每个类型的 id 和 type
}

auto data = entt::resolve<my_type>().data("member"_hs);

if (data) {
    // 获取值
    auto value = data.get(instance).cast<int>();
 
    // 设置值
    data.set(instance, 42);
}

auto func = entt::resolve<my_type>().func("member"_hs);

// 调用函数
if (func) {
    auto result = func.invoke(instance, arg1, arg2);
    if (result) {
        auto return_value = result.cast<int>();
    }
}

if (auto func = entt::resolve<my_type>().func("member"_hs); func) {
    // 函数有效，可以调用
}

for (auto &&[id, type] : entt::resolve<my_type>().base()) {
    // 处理基类类型
}

auto instance = entt::resolve<my_type>().construct(arg1, arg2);
if (instance) {
    // 实例化成功
    auto obj = instance.cast<my_type>();
}

#include <entt/meta/meta.hpp>
 
template<>
struct entt::meta_sequence_container_traits<MyCustomContainer> {
    static size_type size(const MyCustomContainer &container) {
        return container.size();
    }
    static iterator begin(MyCustomContainer &container) {
        return container.begin();
    }
    static iterator end(MyCustomContainer &container) {
        return container.end();
    }
    // 可添加额外的自定义逻辑
};

#include <entt/entt.hpp>
#include <vector>
#include <iostream>
 
int main() {
    std::vector<int> vec{1, 2, 3};
    entt::meta_any any = entt::forward_as_meta(vec);
 
    // 检查是否是序列容器
    if(any.type().is_sequence_container()) {
        // 获取代理对象
        if(auto view = any.as_sequence_container(); view) {
            std::cout << "容器大小：" << view.size() << "\n";
            for(auto &&elem : view) {
                std::cout << "元素值：" << elem.cast<int>() << "\n";
            }
        }
    }
 
    return 0;
}

#include <entt/entt.hpp>
#include <vector>
#include <iostream>
 
int main() {
    std::vector<int> vec{1, 2, 3};
    entt::meta_any any = entt::forward_as_meta(vec);
 
    // 方式 1：直接检查类型
    if(any.type().is_sequence_container()) {
        auto view = any.as_sequence_container();
        if(view) { // 验证代理对象是否有效
            std::cout << "代理对象有效，容器大小：" << view.size() << "\n";
        }
    }
 
    // 方式 2：不检查类型，直接验证代理对象有效性
    if(auto view = any.as_sequence_container(); view) {
        std::cout << "代理对象有效，容器大小：" << view.size() << "\n";
    }
 
    // 如果封装的对象不是容器
    int nonContainer = 42;
    entt::meta_any nonContainerAny = entt::forward_as_meta(nonContainer);
 
    if(auto invalidView = nonContainerAny.as_sequence_container(); !invalidView) {
        std::cout << "无效的代理对象，非容器类型。\n";
    }
 
    return 0;
}

    for(entt::meta_any element : view) {
        // 处理元素
    }

    auto last = view.end();
    view.insert(last, 42); // 在末尾插入整数 42

    auto first = view.begin();
    view.erase(first); // 删除第一个元素

    for(std::size_t pos = 0; pos < view.size(); ++pos) {
    entt::meta_any value = view[pos];
        // 处理元素
    }

    for(std::pair<entt::meta_any, entt::meta_any> element : view) {
        // element.first 是键
        // element.second 是值
    }

    view.insert(view.end().handle(), 42, 'c'); // 插入键 42 和值 'c'

    view.erase(42); // 删除键为 42 的元素

    entt::meta_any value = view[42];

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    int value = 42;
    // 将 int* 封装进 meta_any
    entt::meta_any any{&value};
 
    // 检查是否是指针类型
    if(any.type().is_pointer_like()) {
        // 解引用 meta_any，获取指针指向的值
        if(entt::meta_any ref = *any; ref) {
            // 修改被指向的对象
            ref.cast<int>() = 100;
            std::cout << "Value after modification: " << value << "\n"; // 输出 100
        }
    }
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    int value = 42;
    entt::meta_any any{&value}; // 将 int* 封装为 meta_any
 
    // 示例 1：重复检查（不必要的方式）
    if (any.type().is_pointer_like()) { // 检查是否是指针类型
        if (entt::meta_any ref = *any; ref) { // 再次检查解引用返回的对象是否有效
            std::cout << "Value: " << ref.cast<int>() << "\n";
        }
    }
 
    // 示例 2：仅检查解引用结果的有效性（推荐方式）
    if (entt::meta_any ref = *any; ref) {
        std::cout << "Value: " << ref.cast<int>() << "\n";
    }
 
    // 示例 3：错误类型，返回无效对象
    entt::meta_any nonPointer{value}; // 封装非指针类型
    if (entt::meta_any invalidRef = *nonPointer; !invalidRef) {
        std::cout << "Failed to dereference: Not a pointer-like type.\n";
    }
 
    return 0;
}

    template<typename Type>
    Type &dereference_meta_pointer_like(const   custom_pointer_type<Type> &ptr) {
        return ptr.deref();
    }

    template<typename Type>
    struct  entt::adl_meta_pointer_like<custom_pointer_type<Type>    > {
        static decltype(auto) dereference(const     custom_pointer_type<Type> &ptr) {
            return ptr.deref();
        }
    };

#include <entt/entt.hpp>
#include <memory>
#include <iostream>
 
struct my_type {};
 
int main() {
    auto type = entt::resolve<std::shared_ptr<my_type>>();
    
    if(type.is_template_specialization()) {
        std::cout << "This is a template specialization.\n";
 
        // 获取模板类的元类型
        auto class_type = type.template_type();
        std::cout << "Template class: " << class_type.name() << "\n";
 
        // 获取模板参数的数量
        std::size_t arity = type.template_arity();
        std::cout << "Number of template arguments: " << arity << "\n";
 
        // 获取第一个模板参数的元类型
        auto arg_type = type.template_arg(0u);
        std::cout << "First template argument: " << arg_type.name() << "\n";
    }
 
    return 0;
}

This is a template specialization.
Template class: std::shared_ptr
Number of template arguments: 1
First template argument: my_type

template<typename>
struct function_type;
 
template<typename Ret, typename... Args>
struct function_type<Ret(Args...)> {};

template<typename Ret, typename... Args>
struct entt::meta_template_traits<function_type<Ret(Args...)>> {
    using class_type = meta_class_template_tag<function_type>; // 模板类
    using args_type = type_list<Ret, Args...>; // 模板参数（返回类型 + 参数类型）
};

int a = 42;
double b = a; // 自动从 int 转换为 double

entt::meta_factory<int>{}
    .conv<bool>()
    .conv<char>()
    .conv<double>(); // 针对每种可能的类型都需要注册

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    entt::meta_any any{42};
 
    // 自动允许转换
    if(any.allow_cast<double>()) {
        double value = any.cast<double>();
        std::cout << "Converted value: " << value << "\n"; // 输出 42.0
    }
 
    return 0;
}

enum my_enum { value_a = 1, value_b = 2 };
int x = value_a; // 隐式转换为 int

enum my_enum { value_a = 1, value_b = 2 };
 
int main() {
    entt::meta_any any{value_a};
 
    if(any.allow_cast<int>()) {
        int value = any.cast<int>();
        std::cout << "Converted enum to int: " << value << "\n"; // 输出 1
    }
 
    return 0;
}

enum class scoped_enum : int { value_a = 1, value_b = 2 };
 
int main() {
    scoped_enum value = scoped_enum::value_a;
    entt::meta_any any{value};
 
    if(any.allow_cast<std::underlying_type_t<scoped_enum>>()) {
        int int_value = any.cast<std::underlying_type_t<scoped_enum>>();
        std::cout << "Converted scoped enum to int: " << int_value << "\n"; // 输出 1
    }
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
struct my_class {
    int value;
};
 
int main() {
    entt::meta<my_class>()
        .type("my_class"_hs)
        .conv<int>([](const my_class &instance) {
            return instance.value;
        });
 
    my_class obj{42};
    entt::meta_any any{obj};
 
    if(any.allow_cast<int>()) {
        int value = any.cast<int>();
        std::cout << "Custom conversion: " << value << "\n"; // 输出 42
    }
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    // 通过元类型构造一个整数
    entt::meta_any instance = entt::resolve<int>().construct();
    std::cout << "Constructed int: " << instance.cast<int>() << "\n"; // 输出 0
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
struct my_type {
    my_type() : value(42) {} // 默认构造函数
    int value;
};
 
int main() {
    // 注册用户类型
    entt::meta<my_type>().type("my_type"_hs);
 
    // 通过元类型构造实例
    entt::meta_any instance = entt::resolve<my_type>().construct();
    auto &obj = instance.cast<my_type>();
    std::cout << "Constructed my_type with value: " << obj.value << "\n"; // 输出 42
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
struct my_type {
    int value;
 
    // 默认构造函数
    my_type() : value(0) {}
 
    // 自定义构造函数
    static my_type create() {
        return my_type{100};
    }
};
 
int main() {
    // 注册类型及其自定义构造函数
    entt::meta<my_type>()
        .type("my_type"_hs)
        .ctor<&my_type::create>();
 
    // 通过元类型构造实例
    entt::meta_any instance = entt::resolve<my_type>().construct();
    auto &obj = instance.cast<my_type>();
    std::cout << "Constructed my_type with value: " << obj.value << "\n"; // 输出 100
 
    return 0;
}

struct no_default {
    no_default(int) {}
};
 
// 调用 construct() 会抛出异常
entt::resolve<no_default>().construct(); // 编译或运行时失败

entt::meta_any any = entt::resolve(id).from_void(pointer);

#include <entt/entt.hpp>
#include <iostream>
 
struct my_type {
    int value;
};
 
int main() {
    // 注册类型
    entt::meta<my_type>().type("my_type"_hs);
 
    my_type obj{42};          // 原始对象
    void* pointer = &obj;     // 不透明指针
 
    // 从不透明指针构造 meta_any
    entt::meta_any any = entt::resolve("my_type"_hs).from_void(pointer);
 
    // 操作 meta_any
    if(any) {
        auto& ref = any.cast<my_type>();
        std::cout << "Value: " << ref.value << "\n"; // 输出 42
 
        // 修改对象值
        ref.value = 100;
        std::cout << "Updated value: " << ref.value << "\n"; // 输出 100
    }
 
    return 0;
}

Value: 42
Updated value: 100

struct my_type {
    int value;
};
 
entt::meta<my_type>()
    .data<&my_type::value>("value"_hs); // 默认策略为 as_is

struct my_type {
    void action() { /* 执行某些操作 */ }
};
 
entt::meta<my_type>()
    .func<&my_type::action, entt::as_void_t>("action"_hs); // 返回值被忽略

struct my_type {
    std::string data;
};
 
entt::meta<my_type>()
    .data<&my_type::data, entt::as_ref_t>("data"_hs); // 返回对原对象的引用

#include <entt/entt.hpp>
#include <iostream>
 
enum class my_enum {
    a_value,
    another_value
};
 
int main() {
    // 注册枚举值为元类型的常量
    entt::meta<my_enum>()
        .data<my_enum::a_value>("a_value"_hs)
        .data<my_enum::another_value>("another_value"_hs);
 
    // 获取枚举值
    auto value = entt::resolve<my_enum>()
                     .data("a_value"_hs)
                     .get({})
                     .cast<my_enum>();
 
    std::cout << "Resolved enum value: " << static_cast<int>(value) << "\n"; // 输出 0
 
    return 0;
}

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    // 为 int 类型注册一个命名常量
    entt::meta<int>().data<2048>("max_int"_hs);
 
    // 获取常量值
    auto max = entt::resolve<int>()
                   .data("max_int"_hs)
                   .get({})
                   .cast<int>();
 
    std::cout << "Resolved constant: " << max << "\n"; // 输出 2048
 
    return 0;
}

std::string input = "a_value";
auto enum_data = entt::resolve<my_enum>().data(entt::hashed_string::value(input.c_str()));
if(enum_data) {
    auto value = enum_data.get({}).cast<my_enum>();
    std::cout << "Parsed enum value: " << static_cast<int>(value) << "\n";
}

entt::meta<int>().data<1024>("default_buffer_size"_hs);
auto buffer_size = entt::resolve<int>().data("default_buffer_size"_hs).get({}).cast<int>();
std::cout << "Default buffer size: " << buffer_size << "\n"; // 输出 1024

enum my_traits : std::uint16_t {
    required = 1 << 0,
    hidden = 1 << 1,
    internal = 1 << 2
};
 
entt::meta_factory<my_type>{}.traits(my_traits::required | my_traits::hidden);

auto value = entt::resolve<my_type>().traits<my_traits>();
if(value & my_traits::hidden) {
    std::cout << "This type is hidden.\n";
}

entt::meta_factory<my_type>{}
    .data<&my_type::data_member>("member"_hs)
    .traits(my_traits::internal); // 添加新的特性

struct type_data {
    std::string description;
};
 
entt::meta_factory<my_type>{}.custom<type_data>({"This is a custom type"});

const type_data &value = entt::resolve<my_type>().custom<type_data>();
std::cout << "Description: " << value.description << "\n";

struct function_data {
    std::string tooltip;
};
 
entt::meta_factory<my_type>{}
    .func<&my_type::member_function>("member"_hs)
    .custom<function_data>({"This is a tooltip for the function"});

const function_data &value = entt::resolve<my_type>()
                                 .func("member"_hs)
                                 ->custom<function_data>();
std::cout << "Tooltip: " << value.tooltip << "\n";

entt::meta_reset<my_type>();

entt::meta_reset("my_type"_hs);

entt::meta_reset();

auto &&context = entt::locator<entt::meta_context>::value_or();

entt::meta_context other{}; // 创建新的上下文
auto &&context = entt::locator<entt::meta_context>::value_or();
std::swap(context, other);  // 替换默认上下文

entt::meta_ctx context{}; // 创建自定义上下文
entt::meta_factory<my_type>{context}.type("reflected_type"_hs); // 在自定义上下文中注册类型
 
// 构造 meta_any
entt::meta_any any{context, std::in_place_type<my_type>};
 
// 解析类型
entt::meta_type type = entt::resolve(context, "reflected_type"_hs);

entt::meta_ctx graphics_context{};
entt::meta_ctx physics_context{};
 
// 在图形模块中注册类型
entt::meta_factory<graphics_type>{graphics_context}.type("graphics_type"_hs);
 
// 在物理模块中注册类型
entt::meta_factory<physics_type>{physics_context}.type("physics_type"_hs);

entt::meta_ctx context1{};
entt::meta_ctx context2{};
 
// 根据条件选择上下文
entt::meta_ctx &active_context = (use_context1 ? context1 : context2);
 
// 使用选定的上下文解析类型
auto type = entt::resolve(active_context, "type_name"_hs);

#include <entt/entt.hpp>
#include <iostream>
 
struct graphics_type {
    int width, height;
};
 
struct physics_type {
    float mass, velocity;
};
 
int main() {
    // 创建两个独立的上下文
    entt::meta_ctx graphics_context{};
    entt::meta_ctx physics_context{};
 
    // 在图形上下文中注册类型
    entt::meta_factory<graphics_type>{graphics_context}
        .type("graphics_type"_hs)
        .data<&graphics_type::width>("width"_hs)
        .data<&graphics_type::height>("height"_hs);
 
    // 在物理上下文中注册类型
    entt::meta_factory<physics_type>{physics_context}
        .type("physics_type"_hs)
        .data<&physics_type::mass>("mass"_hs)
        .data<&physics_type::velocity>("velocity"_hs);
 
    // 使用图形上下文解析类型
    auto graphics_type = entt::resolve(graphics_context, "graphics_type"_hs);
    if (graphics_type) {
        std::cout << "graphics_type found in graphics_context.\n";
    }
 
    // 使用物理上下文解析类型
    auto physics_type = entt::resolve(physics_context, "physics_type"_hs);
    if (physics_type) {
        std::cout << "physics_type found in physics_context.\n";
    }
 
    // 尝试在错误的上下文中解析类型
    if (!entt::resolve(graphics_context, "physics_type"_hs)) {
        std::cout << "physics_type not found in graphics_context.\n";
    }
 
    return 0;
}

graphics_type found in graphics_context.
physics_type found in physics_context.
physics_type not found in graphics_context.