EnTT: 核心功能 Core functionalities

    // 空容器
    entt::any empty{};
 
    // 直接初始化
    entt::any any{42};
 
    // 原地构造
    entt::any in_place_type{std::in_place_type<int>, 42};
 
    // 接管动态分配的对象
    entt::any in_place{std::in_place, std::make_unique<int>(42).release()};

    entt::any any = entt::make_any<int>(42);

    int value = 42;
 
    // 创建一个引用容器
    entt::any any{std::in_place_type<int &>, value};
    entt::any cany = entt::make_any<const int &>(value);

    entt::any ref = other.as_ref();

    if (any == empty) {
    // 类型相同且内容相等
    }

// 定义一个缓冲区大小为 sizeof(double[4]) 的 any 类型
using my_any = entt::basic_any<sizeof(double[4])>;

using my_any = entt::basic_any<Size, Alignment>;

// 自定义缓冲区大小和对齐要求
using my_any = entt::basic_any<sizeof(double[4]), alignof(double[4])>;
my_any any{42};

#include <immintrin.h> // 包含 SIMD 类型
 
using simd_any = entt::basic_any<64, alignof(__m256)>; // 缓冲区大小为 64，对齐为 SIMD 的 32 字节
 
simd_any any_simd{__m256{}};

    #include <entt/core/utility.hpp>
 
    unsigned int value = 42; // 42 的二进制是 101010
    std::size_t count = entt::popcount(value); // 返回 3（42 有 3 个二进制位为 1）

    #include <entt/core/utility.hpp>
 
    unsigned int value = 16; // 16 的二进制是 10000
    bool is_power_of_two = entt::has_single_bit(value); // 返回 true
 
    unsigned int not_power_of_two = 18; // 二进制是 10010
    bool result = entt::has_single_bit(not_power_of_two); // 返回 false

    #include <entt/core/utility.hpp>
 
    unsigned int value = 18; // 不小于 18 的最小 2 的幂是 32
    unsigned int next = entt::next_power_of_two(value); // 返回 32

#include <entt/core/utility.hpp>
 
std::size_t value = 123;
std::size_t modulus = 32; // 必须是 2 的幂
 
// 快速模运算
std::size_t result = entt::fast_mod(value, modulus); // 等价于 value % modulus，但更快

entt::compressed_pair pair{0, 3.0};
pair.first() = 42;   // 通过函数访问 `first`
double value = pair.second();

#include <entt/core/utility.hpp>
 
enum class my_flag {
    unknown = 0x01,
    enabled = 0x02,
    disabled = 0x04
};
 
// 注册 my_flag
template<>
struct entt::enum_as_bitmask<my_flag>
    : std::true_type
{};

int main() {
    const my_flag flags = my_flag::enabled | my_flag::disabled;
    const bool is_enabled = !!(flags & my_flag::enabled);
 
    return 0;
}

#include <entt/core/utility.hpp>
 
enum class my_flag {
    unknown = 0x01,
    enabled = 0x02,
    disabled = 0x04,
    _entt_enum_as_bitmask // 特殊标记值，启用位掩码支持
};

const my_flag flags = my_flag::enabled | my_flag::disabled;
const bool has_flag = !!(flags & my_flag::enabled); // 检查是否设置了某标志

    using namespace entt::literals;
    constexpr auto str = "text"_hs;  // 创建一个编译期哈希字符串

    std::string orig{"text"};
    entt::hashed_string str{orig.c_str()};       // 创建哈希字符串
    const auto hash = entt::hashed_string::value(orig.c_str());  // 仅计算哈希值

#include <entt/core/hashed_string.hpp>
#include <iostream>
 
void load(entt::hashed_string::hash_type resource) {
    std::cout << "加载资源，哈希值为: " << resource << std::endl;
}
 
int main() {
    using namespace entt::literals;
 
    constexpr auto resource = "gui/background"_hs;  // 编译期计算哈希值
    load(resource.value());                         // 使用数值哈希值
    return 0;
}

加载资源，哈希值为: 2048734533  // （示例哈希值）

#include <entt/core/hashed_string.hpp>
#include <iostream>
 
int main() {
    using namespace entt::literals;
 
    constexpr auto str = "example"_hs;
    std::cout << "原始字符串: " << str.data() << std::endl;
    std::cout << "哈希值: " << str.value() << std::endl;
 
    return 0;
}

原始字符串: example
哈希值: 1234567890  // （示例哈希值）

#include <entt/core/hashed_string.hpp>
#include <iostream>
#include <string>
 
int main() {
    std::string orig{"runtime_string"};
    entt::hashed_string str{orig.c_str()};  // 创建运行时哈希字符串
 
    std::cout << "原始字符串: " << str.data() << std::endl;
    std::cout << "哈希值: " << str.value() << std::endl;
 
    return 0;
}

constexpr auto str = L"text"_hws;  // 宽字符编译期哈希字符串

#include <entt/core/hashed_string.hpp>
#include <iostream>
 
int main() {
    using namespace entt::literals;
 
    // 创建宽字符哈希字符串
    constexpr auto str = L"example"_hws;
 
    // 输出原始字符串和哈希值
    std::wcout << L"原始宽字符串: " << str.data() << std::endl;
    std::wcout << L"哈希值: " << str.value() << std::endl;
 
    return 0;
}

原始宽字符串: example
哈希值: 1234567890  // （示例哈希值）

"resource/background" -> "resource/bg"

#include <entt/core/utility.hpp> // EnTT 的 input_iterator_pointer
#include <iterator>
#include <utility> // std::pair
 
class example_iterator {
public:
    using value_type = std::pair<int, std::string>;         // 迭代器的值类型
    using pointer = entt::input_iterator_pointer<value_type>; // 指针类型，使用 input_iterator_pointer
    using reference = value_type;                          // 引用类型
    using difference_type = std::ptrdiff_t;                // 差值类型
    using iterator_category = std::input_iterator_tag;     // 输入迭代器类型
 
    example_iterator(int start, int end)
        : current{start}, last{end} {}
 
    // 返回当前值
    reference operator*() const {
        return {current, "Value: " + std::to_string(current)};
    }
 
    // 返回指针
    pointer operator->() const {
        return pointer{**this};
    }
 
    // 前缀自增操作
    example_iterator &operator++() {
        ++current;
        return *this;
    }
 
    // 不等比较
    bool operator!=(const example_iterator &other) const {
        return current != other.current;
    }
 
private:
    int current;
    int last;
};
 

#include <iostream>
#include <string>
 
int main() {
    for (example_iterator it{0, 5}; it != example_iterator{5, 5}; ++it) {
        std::cout << it->first << ": " << it->second << '\n';
    }
    return 0;
}

0: Value: 0
1: Value: 1
2: Value: 2
3: Value: 3
4: Value: 4

#include <entt/core/utility.hpp>
#include <iostream>
 
int main() {
    entt::iota_iterator first{0};   // 起始值为 0
    entt::iota_iterator last{100}; // 结束值为 100（不包括 100）
 
    for (; first != last; ++first) {
        int value = *first;  // 解引用获取当前值
        std::cout << value << " ";
    }
 
    return 0;
}

0 1 2 3 4 5 ... 99

#include <entt/core/utility.hpp>
#include <vector>
#include <iostream>
 
int main() {
    std::vector<int> values = {1, 2, 3, 4, 5};
 
    // 使用 begin 和 end 创建一个可迭代对象
    auto iterable = entt::iterable_adaptor{values.begin(), values.end()};
 
    // 通过标准的范围 for 循环进行迭代
    for (auto value : iterable) {
        std::cout << value << " ";
    }
 
    return 0;
}

1 2 3 4 5

#include <entt/core/utility.hpp>
#include <vector>
#include <iostream>
 
class MyContainer {
public:
    using iterator = std::vector<int>::iterator;
    using const_iterator = std::vector<int>::const_iterator;
 
    MyContainer() : data{1, 2, 3, 4, 5} {}
 
    // 返回可迭代对象
    auto range() {
        return entt::iterable_adaptor{data.begin(), data.end()};
    }
 
private:
    std::vector<int> data;
};
 
int main() {
    MyContainer container;
 
    // 使用 range() 方法获取可迭代对象
    for (auto value : container.range()) {
        std::cout << value << " ";
    }
 
    return 0;
}

1 2 3 4 5

#include <entt/entt.hpp>
#include <iostream>
 
int main() {
    entt::registry registry;
 
    // 创建一些实体并附加组件
    auto entity1 = registry.create();
    auto entity2 = registry.create();
    registry.emplace<int>(entity1, 42);
    registry.emplace<int>(entity2, 84);
 
    // 获取视图
    auto view = registry.view<int>();
 
    // 使用可迭代对象进行迭代
    for (auto [entity, component] : view.each()) {
        std::cout << "Entity: " << entt::to_integral(entity) 
                  << ", Component: " << component << "\n";
    }
 
    return 0;
}

Entity: 0, Component: 42
Entity: 1, Component: 84

#include <entt/core/hashed_string.hpp>
#include <entt/core/monostate.hpp>
#include <iostream>
 
int main() {
    // 用相同的键存储不同类型的值
    entt::monostate<entt::hashed_string{"mykey"}>{} = true;
    entt::monostate<"mykey"_hs>{} = 42;
 
    // 读取值
    const bool b = entt::monostate<entt::hashed_string{"mykey"}>{}; // 获取布尔值
    const int i = entt::monostate<"mykey"_hs>{};                    // 获取整型值
 
    // 输出读取的值
    std::cout << "布尔值: " << std::boolalpha << b << '\n';
    std::cout << "整型值: " << i << '\n';
 
    return 0;
}

auto index = entt::type_index<a_type>::value();

    template<typename Type>
    struct entt::type_index<Type, std::void_t<decltype(Type::index())>> {
        static entt::id_type value() noexcept {
            return Type::index();
        }
    };

auto hash = entt::type_hash<a_type>::value();

auto name = entt::type_name<a_type>::value();

struct my_type { /* ... */ };

// by type
auto info = entt::type_id<a_type>();
 
// by value
auto other = entt::type_id(42);

// 获取类型信息
auto info1 = entt::type_id<int>();
auto info2 = entt::type_id<int>();
 
// 比较两个类型信息
assert(&info1 == &info2); // 返回的是对同一静态实例的引用
 
// 使用info保存类型元信息
std::cout << "Hash: " << info1.hash() << ", Name: " << info1.name() << "\n";

entt::type_info info{std::in_place_type<int>};

    auto idx = entt::type_id<a_type>().index();
    // 或者等价的别名
    auto idx =  entt::type_index<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();

    auto hash = entt::type_id<a_type>().hash();
    // 等价别名
    auto hash = entt::type_hash<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();

    auto name = entt::type_id<my_type>().name();
    // 等价别名
    auto name = entt::type_name<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();

    namespace entt {
        template<>
        struct type_name<foo::MyClass> {
            static constexpr std::string_view value() noexcept {
                return "unique_foo_MyClass";
            }
        };
    }

const auto size = entt::size_of_v<void>;  // 返回 0，因为 void 类型无大小

constexpr bool result = entt::is_applicable<Func, std::tuple<a_type, another_type>>;

using type = entt::constness_as_t<dst_type, const src_type>;  // 如果 src_type 是 const，dst_type 也会变为 const

template<typename Member>
using clazz = entt::member_class_t<Member>;

using type = entt::nth_argument_t<1u, decltype(&clazz::member)>;

constexpr auto constant = entt::integral_constant<42>;  // 定义值为 42 的常量

constexpr auto enemy_tag = entt::integral_constant<"enemy"_hs>;
registry.emplace<enemy_tag>(entity);

registry.emplace<entt::tag<"enemy"_hs>>(entity);

using type = entt::type_list_element<2, entt::type_list<int, float, double>>;
 

constexpr auto index = entt::type_list_index<int, entt::type_list<int, float, double>>::value;

using list = entt::type_list_cat<entt::type_list<int>, entt::type_list<float, double>>;

using unique_list = entt::type_list_unique<entt::type_list<int, float, int, double>>;

constexpr bool contains = entt::type_list_contains<int, entt::type_list<float, int>>::value;

using diff_list = entt::type_list_diff<entt::type_list<int, float>, entt::type_list<float>>;

using transformed_list = entt::type_list_transform<std::add_pointer, entt::type_list<int, float>>;

constexpr auto index = entt::value_list_index<42, entt::value_list<10, 20, 42>>::value;

#include <iostream>
#include <type_traits>
#include <entt/core/ident.hpp>
 
// 定义类型标识符
using id = entt::ident<int, double, char>;
 
int main() {
    // 获取类型对应的标识符
    constexpr auto int_id = id::value<int>;
    constexpr auto double_id = id::value<double>;
    constexpr auto char_id = id::value<char>;
 
    // 打印标识符
    std::cout << "int_id: " << int_id << '\n';       // 输出: 0
    std::cout << "double_id: " << double_id << '\n'; // 输出: 1
    std::cout << "char_id: " << char_id << '\n';     // 输出: 2
 
    // 使用标识符的上下文（例如 switch-case）
    switch (char_id) {
    case id::value<int>:
        std::cout << "Type is int\n";
        break;
    case id::value<double>:
        std::cout << "Type is double\n";
        break;
    case id::value<char>:
        std::cout << "Type is char\n";
        break;
    default:
        std::cout << "Unknown type\n";
    }
}

template<typename> struct ignore_type {};
 
using id = entt::ident<
    int,
    ignore_type<float>,  // 占位，确保其他标识符不变
    double
>;
 
constexpr auto int_id = id::value<int>;     // 0
constexpr auto double_id = id::value<double>; // 2

#include <iostream>
#include <entt/core/family.hpp>
 
// 定义类型标识符生成器
using id = entt::family<struct my_tag>;
 
int main() {
    // 获取类型的运行时标识符
    const auto int_id = id::value<int>;
    const auto double_id = id::value<double>;
 
    // 打印标识符
    std::cout << "int_id: " << int_id << '\n';       // 可能输出: 0
    std::cout << "double_id: " << double_id << '\n'; // 可能输出: 1
 
    // 注意：运行时标识符值可能在不同运行之间变化
}

using physics_id = entt::family<struct physics_tag>;
using graphics_id = entt::family<struct graphics_tag>;
 
const auto physics_int_id = physics_id::value<int>;
const auto graphics_int_id = graphics_id::value<int>;
 
// 同一个类型在不同标签下的标识符互不干扰
std::cout << physics_int_id << '\n'; // 0
std::cout << graphics_int_id << '\n'; // 0

#include <entt/core/utility.hpp>
 
int main() {
    int value = 42;
    int result = entt::identity{}(value);  // 返回原值 42
    return 0;
}

#include <entt/core/utility.hpp>
 
struct clazz {
    void bar(int) {}
    void bar() {}
};
 
int main() {
    // 从重载中选择 void(int) 版本
    auto *member = entt::overload<void(int)>(&clazz::bar);
 
    // 等价于手动写的类型转换
    auto *equivalent = static_cast<void(clazz::*)(int)>(&clazz::bar);
    return 0;
}

#include <entt/core/utility.hpp>
#include <iostream>
 
int main() {
    // 定义支持多种类型的可调用对象
    entt::overloaded func{
        [](int value) { std::cout << "int: " << value << '\n'; },
        [](char value) { std::cout << "char: " << value << '\n'; }
    };
 
    func(42);   // 输出: int: 42
    func('c');  // 输出: char: c
 
    return 0;
}

#include <entt/core/utility.hpp>
#include <iostream>
 
int main() {
    // 使用 Y 组合子实现递归计算高斯和
    entt::y_combinator gauss([](const auto &self, auto value) -> unsigned int {
        return value ? (value + self(value - 1u)) : 0;
    });
 
    const auto result = gauss(3u);  // 计算 3 + 2 + 1 + 0 = 6
    std::cout << "Result: " << result << '\n';  // 输出: Result: 6
 
    return 0;
}

Y = λf.(λx.f (x x)) (λx.f (x x))