Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: built-in support for arrays

Browse Source
This commit is contained in:
Michele Caini
2019-04-19 14:01:00 +02:00
parent cfcc6e1029
commit b983845745
4 changed files with 251 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TODO
+3
View File
@@ -19,4 +19,7 @@
* review sparse set to allow customization (mix pack in the spec, base is position only)
- non-owning groups can iterate pages and skip empty ones, this should mitigate the lack of the packed array
* review 64 bit id: user defined area + dedicated member on the registry to set it
* early out in views using bitmasks with bloom filter like access based on modulus
- standard each, use bitmask to speed up the whole thing and avoid accessing the pools to test for the page
- iterator based each with a couple of iterators passed from outside (use bitmask + has)
* reactive systems
src/entt/meta/factory.hpp
+42 -29
View File
@@ -39,20 +39,6 @@ template<typename Type>
class meta_factory {
static_assert(std::is_object_v<Type> && !(std::is_const_v<Type> || std::is_volatile_v<Type>));
template<auto Data>
static std::enable_if_t<std::is_member_object_pointer_v<decltype(Data)>, decltype(std::declval<Type>().*Data)>
actual_type();
template<auto Data>
static std::enable_if_t<std::is_pointer_v<decltype(Data)>, decltype(*Data)>
actual_type();
template<auto Data>
using data_type = std::remove_reference_t<decltype(meta_factory::actual_type<Data>())>;
template<auto Func>
using func_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
template<typename Node>
inline bool duplicate(const hashed_string &name, const Node *node) ENTT_NOEXCEPT {
return node ? node->name == name || duplicate(name, node->next) : false;
@@ -69,7 +55,7 @@ class meta_factory {
template<typename Owner, typename Property, typename... Other>
internal::meta_prop_node * properties(Property &&property, Other &&... other) {
static std::decay_t<Property> prop{};
static std::remove_cv_t<std::remove_reference_t<Property>> prop{};
static internal::meta_prop_node node{
nullptr,
@@ -99,6 +85,7 @@ class meta_factory {
std::is_void_v<Type>,
std::is_integral_v<Type>,
std::is_floating_point_v<Type>,
std::is_array_v<Type>,
std::is_enum_v<Type>,
std::is_union_v<Type>,
std::is_class_v<Type>,
@@ -106,6 +93,7 @@ class meta_factory {
std::is_function_v<Type>,
std::is_member_object_pointer_v<Type>,
std::is_member_function_pointer_v<Type>,
std::extent_v<Type>,
[]() -> meta_type {
return internal::meta_info<std::remove_pointer_t<Type>>::resolve();
},
@@ -248,7 +236,7 @@ public:
*/
template<typename To>
meta_factory conv() ENTT_NOEXCEPT {
static_assert(std::is_convertible_v<Type, std::decay_t<To>>);
static_assert(std::is_convertible_v<Type, To>);
auto * const type = internal::meta_info<Type>::resolve();
static internal::meta_conv_node node{
@@ -257,7 +245,7 @@ public:
nullptr,
&internal::meta_info<To>::resolve,
[](void *instance) -> meta_any {
return static_cast<std::decay_t<To>>(*static_cast<Type *>(instance));
return static_cast<To>(*static_cast<Type *>(instance));
},
[]() -> meta_conv {
return &node;
@@ -428,8 +416,8 @@ public:
true,
true,
&internal::meta_info<Type>::resolve,
[](meta_handle, meta_any &) { return false; },
[](meta_handle) -> meta_any { return Data; },
[](meta_handle, meta_any, meta_any) { return false; },
[](meta_handle, meta_any) -> meta_any { return Data; },
[]() -> meta_data {
return &node;
}
@@ -437,17 +425,41 @@ public:
node.prop = properties<std::integral_constant<Type, Data>>(std::forward<Property>(property)...);
curr = &node;
} else {
} else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
using data_type = std::remove_reference_t<decltype(std::declval<Type>().*Data)>;
static internal::meta_data_node node{
&internal::meta_info<Type>::template data<Data>,
{},
type,
nullptr,
nullptr,
std::is_const_v<data_type<Data>>,
std::is_const_v<data_type>,
!std::is_member_object_pointer_v<decltype(Data)>,
&internal::meta_info<data_type<Data>>::resolve,
&internal::setter<std::is_const_v<data_type<Data>>, Type, Data>,
&internal::meta_info<data_type>::resolve,
&internal::setter<std::is_const_v<data_type>, Type, Data>,
&internal::getter<Type, Data>,
[]() -> meta_data {
return &node;
}
};
node.prop = properties<std::integral_constant<decltype(Data), Data>>(std::forward<Property>(property)...);
curr = &node;
} else {
static_assert(std::is_pointer_v<decltype(Data)>);
using data_type = std::remove_pointer_t<decltype(Data)>;
static internal::meta_data_node node{
&internal::meta_info<Type>::template data<Data>,
{},
type,
nullptr,
nullptr,
std::is_const_v<data_type>,
!std::is_member_object_pointer_v<decltype(Data)>,
&internal::meta_info<data_type>::resolve,
&internal::setter<std::is_const_v<data_type>, Type, Data>,
&internal::getter<Type, Data>,
[]() -> meta_data {
return &node;
@@ -540,6 +552,7 @@ public:
template<auto Func, typename... Property>
meta_factory func(const char *str, Property &&... property) ENTT_NOEXCEPT {
using owner_type = std::integral_constant<decltype(Func), Func>;
using func_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
auto * const type = internal::meta_info<Type>::resolve();
static internal::meta_func_node node{
@@ -548,13 +561,13 @@ public:
type,
nullptr,
nullptr,
func_type<Func>::size,
func_type<Func>::is_const,
func_type<Func>::is_static,
&internal::meta_info<typename func_type<Func>::return_type>::resolve,
&func_type<Func>::arg,
func_type::size,
func_type::is_const,
func_type::is_static,
&internal::meta_info<typename func_type::return_type>::resolve,
&func_type::arg,
[](meta_handle handle, meta_any *any) {
return internal::invoke<Type, Func>(handle, any, std::make_index_sequence<func_type<Func>::size>{});
return internal::invoke<Type, Func>(handle, any, std::make_index_sequence<func_type::size>{});
},
[]() -> meta_func {
return &node;
src/entt/meta/meta.hpp
+138 -40
View File
@@ -99,8 +99,8 @@ struct meta_data_node {
const bool is_const;
const bool is_static;
meta_type_node *(* const type)();
bool(* const set)(meta_handle, meta_any &);
meta_any(* const get)(meta_handle);
bool(* const set)(meta_handle, meta_any, meta_any);
meta_any(* const get)(meta_handle, meta_any);
meta_data(* const meta)();
};
@@ -123,12 +123,14 @@ struct meta_func_node {
struct meta_type_node {
using size_type = std::size_t;
hashed_string name;
meta_type_node * next;
meta_prop_node * prop;
const bool is_void;
const bool is_integral;
const bool is_floating_point;
const bool is_array;
const bool is_enum;
const bool is_union;
const bool is_class;
@@ -136,6 +138,7 @@ struct meta_type_node {
const bool is_function;
const bool is_member_object_pointer;
const bool is_member_function_pointer;
const size_type extent;
meta_type(* const remove_pointer)();
bool(* const destroy)(meta_handle);
meta_type(* const meta)();
@@ -377,9 +380,9 @@ public:
* @tparam Type Type of object to use to initialize the container.
* @param type An instance of an object to use to initialize the container.
*/
template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::decay_t<Type>, meta_any>>>
template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
meta_any(Type &&type) {
using actual_type = std::decay_t<Type>;
using actual_type = std::remove_cv_t<std::remove_reference_t<Type>>;
node = internal::meta_info<Type>::resolve();
compare_fn = &compare<actual_type>;
@@ -656,7 +659,7 @@ public:
* @tparam Type Type of object to use to initialize the handle.
* @param obj A reference to an object to use to initialize the handle.
*/
template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::decay_t<Type>, meta_handle>>>
template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
meta_handle(Type &&obj) ENTT_NOEXCEPT
: meta_handle{0, std::forward<Type>(obj)}
{}
@@ -1230,22 +1233,56 @@ public:
*/
template<typename Type>
inline bool set(meta_handle handle, Type &&value) const {
meta_any any{std::forward<Type>(value)};
return node->set(handle, any);
return node->set(handle, meta_any{}, std::forward<Type>(value));
}
/**
* @brief Sets the i-th element of an array enclosed by a given meta type.
*
* It must be possible to cast the instance to the parent type of the meta
* data. Otherwise, invoking the setter results in an undefined
* behavior.<br/>
* The type of the value must coincide exactly with that of the array type
* enclosed by the meta data. Otherwise, invoking the setter does nothing.
*
* @tparam Type Type of value to assign.
* @param handle An opaque pointer to an instance of the underlying type.
* @param index Position of the underlying element to set.
* @param value Parameter to use to set the underlying element.
* @return True in case of success, false otherwise.
*/
template<typename Type>
inline bool set(meta_handle handle, std::size_t index, Type &&value) const {
assert(index < node->type()->extent);
return node->set(handle, index, std::forward<Type>(value));
}
/**
* @brief Gets the value of the variable enclosed by a given meta type.
*
* It must be possible to cast the instance to the parent type of the meta
* function. Otherwise, invoking the getter results in an undefined
* behavior.
* data. Otherwise, invoking the getter results in an undefined behavior.
*
* @param handle An opaque pointer to an instance of the underlying type.
* @return A meta any containing the value of the underlying variable.
*/
inline meta_any get(meta_handle handle) const ENTT_NOEXCEPT {
return node->get(handle);
return node->get(handle, meta_any{});
}
/**
* @brief Gets the i-th element of an array enclosed by a given meta type.
*
* It must be possible to cast the instance to the parent type of the meta
* data. Otherwise, invoking the getter results in an undefined behavior.
*
* @param handle An opaque pointer to an instance of the underlying type.
* @param index Position of the underlying element to get.
* @return A meta any containing the value of the underlying element.
*/
inline meta_any get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPT {
assert(index < node->type()->extent);
return node->get(handle, index);
}
/**
@@ -1497,6 +1534,9 @@ class meta_type {
{}
public:
/*! @brief Unsigned integer type. */
using size_type = typename internal::meta_type_node::size_type;
/*! @brief Default constructor. */
inline meta_type() ENTT_NOEXCEPT
: node{nullptr}
@@ -1537,6 +1577,15 @@ public:
return node->is_floating_point;
}
/**
* @brief Indicates whether a given meta type refers to an array type or
* not.
* @return True if the underlying type is an array type, false otherwise.
*/
inline bool is_array() const ENTT_NOEXCEPT {
return node->is_array;
}
/**
* @brief Indicates whether a given meta type refers to an enum or not.
* @return True if the underlying type is an enum, false otherwise.
@@ -1598,6 +1647,16 @@ public:
return node->is_member_function_pointer;
}
/**
* @brief If a given meta type refers to an array type, provides the number
* of elements of the array.
* @return The number of elements of the array if the underlying type is an
* array type, 0 otherwise.
*/
inline size_type extent() const ENTT_NOEXCEPT {
return node->extent;
}
/**
* @brief Provides the meta type for which the pointer is defined.
* @return The meta type for which the pointer is defined or this meta type
@@ -2010,25 +2069,29 @@ struct meta_function_helper<std::integral_constant<decltype(Func), Func>>: declt
template<typename Type>
inline bool destroy([[maybe_unused]] meta_handle handle) {
if constexpr(std::is_object_v<Type>) {
return handle.type() == meta_info<Type>::resolve()->meta()
? (static_cast<Type *>(handle.data())->~Type(), true)
: false;
} else {
return false;
bool accepted = false;
if constexpr(std::is_object_v<Type> && !std::is_array_v<Type>) {
accepted = (handle.type() == meta_info<Type>::resolve()->meta());
if(accepted) {
static_cast<Type *>(handle.data())->~Type();
}
}
return accepted;
}
template<typename Type, typename... Args, std::size_t... Indexes>
inline meta_any construct(meta_any * const args, std::index_sequence<Indexes...>) {
[[maybe_unused]] std::array<bool, sizeof...(Args)> can_cast{{(args+Indexes)->can_cast<std::decay_t<Args>>()...}};
[[maybe_unused]] std::array<bool, sizeof...(Args)> can_convert{{(std::get<Indexes>(can_cast) ? false : (args+Indexes)->can_convert<std::decay_t<Args>>())...}};
[[maybe_unused]] std::array<bool, sizeof...(Args)> can_cast{{(args+Indexes)->can_cast<std::remove_cv_t<std::remove_reference_t<Args>>>()...}};
[[maybe_unused]] std::array<bool, sizeof...(Args)> can_convert{{(std::get<Indexes>(can_cast) ? false : (args+Indexes)->can_convert<std::remove_cv_t<std::remove_reference_t<Args>>>())...}};
meta_any any{};
if(((std::get<Indexes>(can_cast) || std::get<Indexes>(can_convert)) && ...)) {
((std::get<Indexes>(can_convert) ? void((args+Indexes)->convert<std::decay_t<Args>>()) : void()), ...);
any = Type{(args+Indexes)->cast<std::decay_t<Args>>()...};
((std::get<Indexes>(can_convert) ? void((args+Indexes)->convert<std::remove_cv_t<std::remove_reference_t<Args>>>()) : void()), ...);
any = Type{(args+Indexes)->cast<std::remove_cv_t<std::remove_reference_t<Args>>>()...};
}
return any;
@@ -2036,55 +2099,88 @@ inline meta_any construct(meta_any * const args, std::index_sequence<Indexes...>
template<bool Const, typename Type, auto Data>
bool setter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any &any) {
bool setter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index, [[maybe_unused]] meta_any value) {
bool accepted = false;
if constexpr(Const) {
return accepted;
} else {
if constexpr(!Const) {
if constexpr(std::is_function_v<std::remove_pointer_t<decltype(Data)>> || std::is_member_function_pointer_v<decltype(Data)>) {
using helper_type = meta_function_helper<std::integral_constant<decltype(Data), Data>>;
using data_type = std::decay_t<std::tuple_element_t<!std::is_member_function_pointer_v<decltype(Data)>, typename helper_type::args_type>>;
static_assert(std::is_invocable_v<decltype(Data), Type *, data_type>);
accepted = any.can_cast<data_type>() || any.convert<data_type>();
accepted = value.can_cast<data_type>() || value.convert<data_type>();
auto *clazz = handle.try_cast<Type>();
if(accepted && clazz) {
std::invoke(Data, clazz, any.cast<data_type>());
std::invoke(Data, clazz, value.cast<data_type>());
}
} else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
using data_type = std::decay_t<decltype(std::declval<Type>().*Data)>;
using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
static_assert(std::is_invocable_v<decltype(Data), Type>);
accepted = any.can_cast<data_type>() || any.convert<data_type>();
auto *clazz = handle.try_cast<Type>();
if(accepted && clazz) {
std::invoke(Data, clazz) = any.cast<data_type>();
if constexpr(std::is_array_v<data_type>) {
using underlying_type = std::remove_extent_t<data_type>;
accepted = index.can_cast<std::size_t>() && (value.can_cast<underlying_type>() || value.convert<underlying_type>());
if(accepted && clazz) {
std::invoke(Data, clazz)[index.cast<std::size_t>()] = value.cast<underlying_type>();
}
} else {
accepted = value.can_cast<data_type>() || value.convert<data_type>();
if(accepted && clazz) {
std::invoke(Data, clazz) = value.cast<data_type>();
}
}
} else {
static_assert(std::is_pointer_v<decltype(Data)>);
using data_type = std::decay_t<decltype(*Data)>;
accepted = any.can_cast<data_type>() || any.convert<data_type>();
using data_type = std::remove_cv_t<std::remove_reference_t<decltype(*Data)>>;
if(accepted) {
*Data = any.cast<data_type>();
if constexpr(std::is_array_v<data_type>) {
using underlying_type = std::remove_extent_t<data_type>;
accepted = index.can_cast<std::size_t>() && (value.can_cast<underlying_type>() || value.convert<underlying_type>());
if(accepted) {
(*Data)[index.cast<std::size_t>()] = value.cast<underlying_type>();
}
} else {
accepted = value.can_cast<data_type>() || value.convert<data_type>();
if(accepted) {
*Data = value.cast<data_type>();
}
}
}
return accepted;
}
return accepted;
}
template<typename Type, auto Data>
inline meta_any getter([[maybe_unused]] meta_handle handle) {
if constexpr(std::is_function_v<std::remove_pointer_t<decltype(Data)>> || std::is_member_pointer_v<decltype(Data)>) {
static_assert(std::is_invocable_v<decltype(Data), Type *>);
inline meta_any getter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index) {
if constexpr(std::is_function_v<std::remove_pointer_t<decltype(Data)>> || std::is_member_function_pointer_v<decltype(Data)>) {
static_assert(std::is_invocable_v<decltype(Data), Type *>);
auto *clazz = handle.try_cast<Type>();
return clazz ? std::invoke(Data, clazz) : meta_any{};
} else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
static_assert(std::is_invocable_v<decltype(Data), Type *>);
auto *clazz = handle.try_cast<Type>();
if constexpr(std::is_array_v<data_type>) {
return (clazz && index.can_cast<std::size_t>()) ? std::invoke(Data, clazz)[index.cast<std::size_t>()] : meta_any{};
} else {
return clazz ? std::invoke(Data, clazz) : meta_any{};
}
} else {
static_assert(std::is_pointer_v<decltype(Data)>);
return meta_any{*Data};
if constexpr(std::is_array_v<std::remove_pointer_t<decltype(Data)>>) {
return index.can_cast<std::size_t>() ? (*Data)[index.cast<std::size_t>()] : meta_any{};
} else {
return *Data;
}
}
}
@@ -2141,6 +2237,7 @@ meta_type_node * meta_node<Type>::resolve() ENTT_NOEXCEPT {
std::is_void_v<Type>,
std::is_integral_v<Type>,
std::is_floating_point_v<Type>,
std::is_array_v<Type>,
std::is_enum_v<Type>,
std::is_union_v<Type>,
std::is_class_v<Type>,
@@ -2148,6 +2245,7 @@ meta_type_node * meta_node<Type>::resolve() ENTT_NOEXCEPT {
std::is_function_v<Type>,
std::is_member_object_pointer_v<Type>,
std::is_member_function_pointer_v<Type>,
std::extent_v<Type>,
[]() -> meta_type {
return internal::meta_info<std::remove_pointer_t<Type>>::resolve();
},
test/entt/meta/meta.cpp
+68
View File
@@ -71,6 +71,11 @@ struct data_type {
empty_type empty{};
};
struct array_type {
static inline int global[3];
int local[3];
};
struct func_type {
int f(const base_type &, int a, int b) { return f(a, b); }
int f(int a, int b) { value = a; return b*b; }
@@ -154,6 +159,10 @@ struct Meta: public ::testing::Test {
.data<&data_type::k>("k", std::make_pair(properties::prop_int, 3))
.data<&data_type::empty>("empty");
entt::reflect<array_type>("array")
.data<&array_type::global>("global")
.data<&array_type::local>("local");
entt::reflect<func_type>("func")
.func<entt::overload<int(const base_type &, int, int)>(&func_type::f)>("f3")
.func<entt::overload<int(int, int)>(&func_type::f)>("f2", std::make_pair(properties::prop_bool, false))
@@ -1010,6 +1019,65 @@ TEST_F(Meta, MetaDataSetterGetterMixed) {
ASSERT_EQ(data.get(instance).cast<int>(), 42);
}
TEST_F(Meta, MetaDataArrayStatic) {
auto data = entt::resolve<array_type>().data("global");
array_type::global[0] = 3;
array_type::global[1] = 5;
array_type::global[2] = 7;
ASSERT_TRUE(data);
ASSERT_NE(data, entt::meta_data{});
ASSERT_EQ(data.parent(), entt::resolve("array"));
ASSERT_EQ(data.type(), entt::resolve<int[3]>());
ASSERT_STREQ(data.name(), "global");
ASSERT_FALSE(data.is_const());
ASSERT_TRUE(data.is_static());
ASSERT_TRUE(data.type().is_array());
ASSERT_EQ(data.type().extent(), 3);
ASSERT_EQ(data.get(nullptr, 0).cast<int>(), 3);
ASSERT_EQ(data.get(nullptr, 1).cast<int>(), 5);
ASSERT_EQ(data.get(nullptr, 2).cast<int>(), 7);
ASSERT_FALSE(data.set(nullptr, 0, 'c'));
ASSERT_EQ(data.get(nullptr, 0).cast<int>(), 3);
ASSERT_TRUE(data.set(nullptr, 0, data.get(nullptr, 0).cast<int>()+2));
ASSERT_TRUE(data.set(nullptr, 1, data.get(nullptr, 1).cast<int>()+2));
ASSERT_TRUE(data.set(nullptr, 2, data.get(nullptr, 2).cast<int>()+2));
ASSERT_EQ(data.get(nullptr, 0).cast<int>(), 5);
ASSERT_EQ(data.get(nullptr, 1).cast<int>(), 7);
ASSERT_EQ(data.get(nullptr, 2).cast<int>(), 9);
}
TEST_F(Meta, MetaDataArray) {
auto data = entt::resolve<array_type>().data("local");
array_type instance;
instance.local[0] = 3;
instance.local[1] = 5;
instance.local[2] = 7;
ASSERT_TRUE(data);
ASSERT_NE(data, entt::meta_data{});
ASSERT_EQ(data.parent(), entt::resolve("array"));
ASSERT_EQ(data.type(), entt::resolve<int[3]>());
ASSERT_STREQ(data.name(), "local");
ASSERT_FALSE(data.is_const());
ASSERT_FALSE(data.is_static());
ASSERT_TRUE(data.type().is_array());
ASSERT_EQ(data.type().extent(), 3);
ASSERT_EQ(data.get(instance, 0).cast<int>(), 3);
ASSERT_EQ(data.get(instance, 1).cast<int>(), 5);
ASSERT_EQ(data.get(instance, 2).cast<int>(), 7);
ASSERT_FALSE(data.set(instance, 0, 'c'));
ASSERT_EQ(data.get(instance, 0).cast<int>(), 3);
ASSERT_TRUE(data.set(instance, 0, data.get(instance, 0).cast<int>()+2));
ASSERT_TRUE(data.set(instance, 1, data.get(instance, 1).cast<int>()+2));
ASSERT_TRUE(data.set(instance, 2, data.get(instance, 2).cast<int>()+2));
ASSERT_EQ(data.get(instance, 0).cast<int>(), 5);
ASSERT_EQ(data.get(instance, 1).cast<int>(), 7);
ASSERT_EQ(data.get(instance, 2).cast<int>(), 9);
}
TEST_F(Meta, MetaFunc) {
auto func = entt::resolve<func_type>().func("f2");
func_type instance{};