BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-15 03:45:30 +07:00
Code Issues Packages Projects Releases Wiki Activity

reduce the number of ::instance() calls

Browse Source
This commit is contained in:
BlackMATov
2023-02-13 23:55:55 +07:00
parent 4edc174ec3
commit 7a56ba97ad
26 changed files with 1340 additions and 1114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

571
develop/singles/headers/meta.hpp/meta_all.hpp
View File

File diff suppressed because it is too large Load Diff

224
develop/untests/meta_features/diamond_tests.cpp
View File

@@ -29,6 +29,10 @@ namespace
TEST_CASE("meta/meta_features/diamond") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::uinst;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
meta::class_<A>();
meta::class_<B>().base_<A>();
@@ -120,43 +124,43 @@ TEST_CASE("meta/meta_features/diamond") {
using meta::detail::pointer_upcast;
{
A a;
CHECK(pointer_upcast<A>(&a) == &a);
CHECK_FALSE(pointer_upcast<B>(&a));
CHECK_FALSE(pointer_upcast<C>(&a));
CHECK_FALSE(pointer_upcast<D>(&a));
CHECK_FALSE(pointer_upcast<E>(&a));
CHECK(pointer_upcast<A>(r, &a) == &a);
CHECK_FALSE(pointer_upcast<B>(r, &a));
CHECK_FALSE(pointer_upcast<C>(r, &a));
CHECK_FALSE(pointer_upcast<D>(r, &a));
CHECK_FALSE(pointer_upcast<E>(r, &a));
}
{
const B b;
CHECK(pointer_upcast<A>(&b) == &b);
CHECK(pointer_upcast<B>(&b) == &b);
CHECK_FALSE(pointer_upcast<C>(&b));
CHECK_FALSE(pointer_upcast<D>(&b));
CHECK_FALSE(pointer_upcast<E>(&b));
CHECK(pointer_upcast<A>(r, &b) == &b);
CHECK(pointer_upcast<B>(r, &b) == &b);
CHECK_FALSE(pointer_upcast<C>(r, &b));
CHECK_FALSE(pointer_upcast<D>(r, &b));
CHECK_FALSE(pointer_upcast<E>(r, &b));
}
{
C c;
CHECK(pointer_upcast<A>(&c) == &c);
CHECK_FALSE(pointer_upcast<B>(&c));
CHECK(pointer_upcast<C>(&c) == &c);
CHECK_FALSE(pointer_upcast<D>(&c));
CHECK_FALSE(pointer_upcast<E>(&c));
CHECK(pointer_upcast<A>(r, &c) == &c);
CHECK_FALSE(pointer_upcast<B>(r, &c));
CHECK(pointer_upcast<C>(r, &c) == &c);
CHECK_FALSE(pointer_upcast<D>(r, &c));
CHECK_FALSE(pointer_upcast<E>(r, &c));
}
{
const D d;
CHECK(pointer_upcast<A>(&d) == &d);
CHECK(pointer_upcast<B>(&d) == &d);
CHECK(pointer_upcast<C>(&d) == &d);
CHECK(pointer_upcast<D>(&d) == &d);
CHECK_FALSE(pointer_upcast<E>(&d));
CHECK(pointer_upcast<A>(r, &d) == &d);
CHECK(pointer_upcast<B>(r, &d) == &d);
CHECK(pointer_upcast<C>(r, &d) == &d);
CHECK(pointer_upcast<D>(r, &d) == &d);
CHECK_FALSE(pointer_upcast<E>(r, &d));
}
{
E e;
CHECK_FALSE(pointer_upcast<A>(&e));
CHECK_FALSE(pointer_upcast<B>(&e));
CHECK_FALSE(pointer_upcast<C>(&e));
CHECK_FALSE(pointer_upcast<D>(&e));
CHECK(pointer_upcast<E>(&e) == &e);
CHECK_FALSE(pointer_upcast<A>(r, &e));
CHECK_FALSE(pointer_upcast<B>(r, &e));
CHECK_FALSE(pointer_upcast<C>(r, &e));
CHECK_FALSE(pointer_upcast<D>(r, &e));
CHECK(pointer_upcast<E>(r, &e) == &e);
}
}
@@ -166,155 +170,155 @@ TEST_CASE("meta/meta_features/diamond") {
meta::uvalue a_val{&a};
CHECK(*static_cast<A**>(a_val.get_data()) == &a);
meta::detail::uarg a_arg{a_val};
uarg a_arg{r, a_val};
CHECK(a_arg.can_cast_to<A*>());
CHECK(!a_arg.can_cast_to<B*>());
CHECK(!a_arg.can_cast_to<C*>());
CHECK(!a_arg.can_cast_to<D*>());
CHECK(!a_arg.can_cast_to<E*>());
CHECK(a_arg.can_cast_to<A*>(r));
CHECK(!a_arg.can_cast_to<B*>(r));
CHECK(!a_arg.can_cast_to<C*>(r));
CHECK(!a_arg.can_cast_to<D*>(r));
CHECK(!a_arg.can_cast_to<E*>(r));
CHECK(a_arg.cast<A*>() == static_cast<A*>(&a));
CHECK(a_arg.cast<A*>(r) == static_cast<A*>(&a));
}
{
B b;
meta::uvalue b_val{&b};
CHECK(*static_cast<B**>(b_val.get_data()) == &b);
meta::detail::uarg b_arg{b_val};
uarg b_arg{r, b_val};
CHECK(b_arg.can_cast_to<A*>());
CHECK(b_arg.can_cast_to<B*>());
CHECK(!b_arg.can_cast_to<C*>());
CHECK(!b_arg.can_cast_to<D*>());
CHECK(!b_arg.can_cast_to<E*>());
CHECK(b_arg.can_cast_to<A*>(r));
CHECK(b_arg.can_cast_to<B*>(r));
CHECK(!b_arg.can_cast_to<C*>(r));
CHECK(!b_arg.can_cast_to<D*>(r));
CHECK(!b_arg.can_cast_to<E*>(r));
CHECK(b_arg.cast<A*>() == static_cast<A*>(&b));
CHECK(b_arg.cast<B*>() == static_cast<B*>(&b));
CHECK(b_arg.cast<A*>(r) == static_cast<A*>(&b));
CHECK(b_arg.cast<B*>(r) == static_cast<B*>(&b));
}
{
C c;
meta::uvalue c_val{&c};
CHECK(*static_cast<C**>(c_val.get_data()) == &c);
meta::detail::uarg c_arg{c_val};
uarg c_arg{r, c_val};
CHECK(c_arg.can_cast_to<A*>());
CHECK(!c_arg.can_cast_to<B*>());
CHECK(c_arg.can_cast_to<C*>());
CHECK(!c_arg.can_cast_to<D*>());
CHECK(!c_arg.can_cast_to<E*>());
CHECK(c_arg.can_cast_to<A*>(r));
CHECK(!c_arg.can_cast_to<B*>(r));
CHECK(c_arg.can_cast_to<C*>(r));
CHECK(!c_arg.can_cast_to<D*>(r));
CHECK(!c_arg.can_cast_to<E*>(r));
CHECK(c_arg.cast<A*>() == static_cast<A*>(&c));
CHECK(c_arg.cast<C*>() == static_cast<C*>(&c));
CHECK(c_arg.cast<A*>(r) == static_cast<A*>(&c));
CHECK(c_arg.cast<C*>(r) == static_cast<C*>(&c));
}
{
D d;
meta::uvalue d_val{&d};
CHECK(*static_cast<D**>(d_val.get_data()) == &d);
meta::detail::uarg d_arg{d_val};
uarg d_arg{r, d_val};
CHECK(d_arg.can_cast_to<A*>());
CHECK(d_arg.can_cast_to<B*>());
CHECK(d_arg.can_cast_to<C*>());
CHECK(d_arg.can_cast_to<D*>());
CHECK(!d_arg.can_cast_to<E*>());
CHECK(d_arg.can_cast_to<A*>(r));
CHECK(d_arg.can_cast_to<B*>(r));
CHECK(d_arg.can_cast_to<C*>(r));
CHECK(d_arg.can_cast_to<D*>(r));
CHECK(!d_arg.can_cast_to<E*>(r));
CHECK(d_arg.cast<A*>() == static_cast<A*>(&d));
CHECK(d_arg.cast<B*>() == static_cast<B*>(&d));
CHECK(d_arg.cast<C*>() == static_cast<C*>(&d));
CHECK(d_arg.cast<D*>() == static_cast<D*>(&d));
CHECK(d_arg.cast<A*>(r) == static_cast<A*>(&d));
CHECK(d_arg.cast<B*>(r) == static_cast<B*>(&d));
CHECK(d_arg.cast<C*>(r) == static_cast<C*>(&d));
CHECK(d_arg.cast<D*>(r) == static_cast<D*>(&d));
}
{
E e;
meta::uvalue e_val{&e};
CHECK(*static_cast<E**>(e_val.get_data()) == &e);
meta::detail::uarg e_arg{e_val};
uarg e_arg{r, e_val};
CHECK(!e_arg.can_cast_to<A*>());
CHECK(!e_arg.can_cast_to<B*>());
CHECK(!e_arg.can_cast_to<C*>());
CHECK(!e_arg.can_cast_to<D*>());
CHECK(e_arg.can_cast_to<E*>());
CHECK(!e_arg.can_cast_to<A*>(r));
CHECK(!e_arg.can_cast_to<B*>(r));
CHECK(!e_arg.can_cast_to<C*>(r));
CHECK(!e_arg.can_cast_to<D*>(r));
CHECK(e_arg.can_cast_to<E*>(r));
CHECK(e_arg.cast<E*>() == static_cast<E*>(&e));
CHECK(e_arg.cast<E*>(r) == static_cast<E*>(&e));
}
}
SUBCASE("inst/cast") {
{
meta::uvalue a_val{A{}};
meta::detail::uinst a_inst{a_val};
uinst a_inst{r, a_val};
CHECK(a_inst.can_cast_to<A&>());
CHECK_FALSE(a_inst.can_cast_to<B&>());
CHECK_FALSE(a_inst.can_cast_to<C&>());
CHECK_FALSE(a_inst.can_cast_to<D&>());
CHECK_FALSE(a_inst.can_cast_to<E&>());
CHECK(a_inst.can_cast_to<A&>(r));
CHECK_FALSE(a_inst.can_cast_to<B&>(r));
CHECK_FALSE(a_inst.can_cast_to<C&>(r));
CHECK_FALSE(a_inst.can_cast_to<D&>(r));
CHECK_FALSE(a_inst.can_cast_to<E&>(r));
CHECK(&a_inst.cast<A&>() == &a_val.get_as<A>());
CHECK(&a_inst.cast<A&>(r) == &a_val.get_as<A>());
}
{
meta::uvalue b_val{B{}};
meta::detail::uinst b_inst{b_val};
uinst b_inst{r, b_val};
CHECK(b_inst.can_cast_to<A&>());
CHECK(b_inst.can_cast_to<B&>());
CHECK_FALSE(b_inst.can_cast_to<C&>());
CHECK_FALSE(b_inst.can_cast_to<D&>());
CHECK_FALSE(b_inst.can_cast_to<E&>());
CHECK(b_inst.can_cast_to<A&>(r));
CHECK(b_inst.can_cast_to<B&>(r));
CHECK_FALSE(b_inst.can_cast_to<C&>(r));
CHECK_FALSE(b_inst.can_cast_to<D&>(r));
CHECK_FALSE(b_inst.can_cast_to<E&>(r));
CHECK(&b_inst.cast<A&>() == &b_val.get_as<B>());
CHECK(&b_inst.cast<B&>() == &b_val.get_as<B>());
CHECK(&b_inst.cast<A&>(r) == &b_val.get_as<B>());
CHECK(&b_inst.cast<B&>(r) == &b_val.get_as<B>());
CHECK(&b_inst.cast<A&>() == &b_val.get_as<B>());
CHECK(&b_inst.cast<A&>(r) == &b_val.get_as<B>());
}
{
meta::uvalue c_val{C{}};
meta::detail::uinst c_inst{c_val};
uinst c_inst{r, c_val};
CHECK(c_inst.can_cast_to<A&>());
CHECK_FALSE(c_inst.can_cast_to<B&>());
CHECK(c_inst.can_cast_to<C&>());
CHECK_FALSE(c_inst.can_cast_to<D&>());
CHECK_FALSE(c_inst.can_cast_to<E&>());
CHECK(c_inst.can_cast_to<A&>(r));
CHECK_FALSE(c_inst.can_cast_to<B&>(r));
CHECK(c_inst.can_cast_to<C&>(r));
CHECK_FALSE(c_inst.can_cast_to<D&>(r));
CHECK_FALSE(c_inst.can_cast_to<E&>(r));
CHECK(&c_inst.cast<A&>() == &c_val.get_as<C>());
CHECK(&c_inst.cast<C&>() == &c_val.get_as<C>());
CHECK(&c_inst.cast<A&>(r) == &c_val.get_as<C>());
CHECK(&c_inst.cast<C&>(r) == &c_val.get_as<C>());
}
{
meta::uvalue d_val{D{}};
meta::detail::uinst d_inst{d_val};
uinst d_inst{r, d_val};
CHECK(d_inst.can_cast_to<A&>());
CHECK(d_inst.can_cast_to<B&>());
CHECK(d_inst.can_cast_to<C&>());
CHECK(d_inst.can_cast_to<D&>());
CHECK_FALSE(d_inst.can_cast_to<E&>());
CHECK(d_inst.can_cast_to<A&>(r));
CHECK(d_inst.can_cast_to<B&>(r));
CHECK(d_inst.can_cast_to<C&>(r));
CHECK(d_inst.can_cast_to<D&>(r));
CHECK_FALSE(d_inst.can_cast_to<E&>(r));
CHECK(&d_inst.cast<A&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<B&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<C&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<D&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<A&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<B&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<C&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<D&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<A&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<B&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<C&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<D&>() == &d_val.get_as<D>());
CHECK(&d_inst.cast<A&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<B&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<C&>(r) == &d_val.get_as<D>());
CHECK(&d_inst.cast<D&>(r) == &d_val.get_as<D>());
}
{
meta::uvalue e_val{E{}};
meta::detail::uinst e_inst{e_val};
uinst e_inst{r, e_val};
CHECK_FALSE(e_inst.can_cast_to<A&>());
CHECK_FALSE(e_inst.can_cast_to<B&>());
CHECK_FALSE(e_inst.can_cast_to<C&>());
CHECK_FALSE(e_inst.can_cast_to<D&>());
CHECK(e_inst.can_cast_to<E&>());
CHECK_FALSE(e_inst.can_cast_to<A&>(r));
CHECK_FALSE(e_inst.can_cast_to<B&>(r));
CHECK_FALSE(e_inst.can_cast_to<C&>(r));
CHECK_FALSE(e_inst.can_cast_to<D&>(r));
CHECK(e_inst.can_cast_to<E&>(r));
CHECK(&e_inst.cast<E&>() == &e_val.get_as<E>());
CHECK(&e_inst.cast<E&>(r) == &e_val.get_as<E>());
}
}

306
develop/untests/meta_utilities/arg2_tests.cpp
View File

@@ -61,6 +61,8 @@ TEST_CASE("meta/meta_utilities/arg2") {
TEST_CASE("meta/meta_utilities/arg2/cast") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
auto LV = []() -> D& { static D v; return v; };
auto CLV = []() -> const D& { static D v; return v; };
@@ -100,254 +102,254 @@ TEST_CASE("meta/meta_utilities/arg2/cast") {
A::move_ctors_ = 0;
SUBCASE("LV") {
CHECK(uarg{LV()}.can_cast_to<A>());
CHECK(uarg{LV()}.can_cast_to<const A>());
CHECK(uarg{LV()}.can_cast_to<A&>());
CHECK(uarg{LV()}.can_cast_to<const A&>());
CHECK_FALSE(uarg{LV()}.can_cast_to<A&&>());
CHECK_FALSE(uarg{LV()}.can_cast_to<const A&&>());
CHECK(uarg{r, LV()}.can_cast_to<A>(r));
CHECK(uarg{r, LV()}.can_cast_to<const A>(r));
CHECK(uarg{r, LV()}.can_cast_to<A&>(r));
CHECK(uarg{r, LV()}.can_cast_to<const A&>(r));
CHECK_FALSE(uarg{r, LV()}.can_cast_to<A&&>(r));
CHECK_FALSE(uarg{r, LV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{LV()}.cast<A>().f() == 1);
CHECK(uarg{LV()}.cast<const A>().f() == 1);
CHECK(uarg{LV()}.cast<A&>().f() == 1);
CHECK(uarg{LV()}.cast<const A&>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{LV()}.cast<A&&>());
// CHECK_THROWS(std::ignore = uarg{LV()}.cast<const A&&>());
CHECK(uarg{r, LV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, LV()}.cast<const A>(r).f() == 1);
CHECK(uarg{r, LV()}.cast<A&>(r).f() == 1);
CHECK(uarg{r, LV()}.cast<const A&>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, LV()}.cast<A&&>(r));
// CHECK_THROWS(std::ignore = uarg{r, LV()}.cast<const A&&>(r));
CHECK(A::copy_ctors_ == 2);
CHECK(A::move_ctors_ == 0);
}
SUBCASE("CLV") {
CHECK(uarg{CLV()}.can_cast_to<A>());
CHECK(uarg{CLV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{CLV()}.can_cast_to<A&>());
CHECK(uarg{CLV()}.can_cast_to<const A&>());
CHECK_FALSE(uarg{CLV()}.can_cast_to<A&&>());
CHECK_FALSE(uarg{CLV()}.can_cast_to<const A&&>());
CHECK(uarg{r, CLV()}.can_cast_to<A>(r));
CHECK(uarg{r, CLV()}.can_cast_to<const A>(r));
CHECK_FALSE(uarg{r, CLV()}.can_cast_to<A&>(r));
CHECK(uarg{r, CLV()}.can_cast_to<const A&>(r));
CHECK_FALSE(uarg{r, CLV()}.can_cast_to<A&&>(r));
CHECK_FALSE(uarg{r, CLV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{CLV()}.cast<A>().f() == 1);
CHECK(uarg{CLV()}.cast<const A>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CLV()}.cast<A&>());
CHECK(uarg{CLV()}.cast<const A&>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CLV()}.cast<A&&>());
// CHECK_THROWS(std::ignore = uarg{CLV()}.cast<const A&&>());
CHECK(uarg{r, CLV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, CLV()}.cast<const A>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast<A&>(r));
CHECK(uarg{r, CLV()}.cast<const A&>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast<A&&>(r));
// CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast<const A&&>(r));
CHECK(A::copy_ctors_ == 2);
CHECK(A::move_ctors_ == 0);
}
SUBCASE("XV") {
CHECK(uarg{XV()}.can_cast_to<A>());
CHECK(uarg{XV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{XV()}.can_cast_to<A&>());
CHECK(uarg{XV()}.can_cast_to<const A&>());
CHECK(uarg{XV()}.can_cast_to<A&&>());
CHECK(uarg{XV()}.can_cast_to<const A&&>());
CHECK(uarg{r, XV()}.can_cast_to<A>(r));
CHECK(uarg{r, XV()}.can_cast_to<const A>(r));
CHECK_FALSE(uarg{r, XV()}.can_cast_to<A&>(r));
CHECK(uarg{r, XV()}.can_cast_to<const A&>(r));
CHECK(uarg{r, XV()}.can_cast_to<A&&>(r));
CHECK(uarg{r, XV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{XV()}.cast<A>().f() == 1);
CHECK(uarg{XV()}.cast<const A>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{XV()}.cast<A&>());
CHECK(uarg{XV()}.cast<const A&>().f() == 1);
CHECK(uarg{XV()}.cast<A&&>().f() == 1);
CHECK(uarg{XV()}.cast<const A&&>().f() == 1);
CHECK(uarg{r, XV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, XV()}.cast<const A>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, XV()}.cast<A&>(r));
CHECK(uarg{r, XV()}.cast<const A&>(r).f() == 1);
CHECK(uarg{r, XV()}.cast<A&&>(r).f() == 1);
CHECK(uarg{r, XV()}.cast<const A&&>(r).f() == 1);
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 2);
}
SUBCASE("CXV") {
CHECK(uarg{CXV()}.can_cast_to<A>());
CHECK(uarg{CXV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{CXV()}.can_cast_to<A&>());
CHECK(uarg{CXV()}.can_cast_to<const A&>());
CHECK_FALSE(uarg{CXV()}.can_cast_to<A&&>());
CHECK(uarg{CXV()}.can_cast_to<const A&&>());
CHECK(uarg{r, CXV()}.can_cast_to<A>(r));
CHECK(uarg{r, CXV()}.can_cast_to<const A>(r));
CHECK_FALSE(uarg{r, CXV()}.can_cast_to<A&>(r));
CHECK(uarg{r, CXV()}.can_cast_to<const A&>(r));
CHECK_FALSE(uarg{r, CXV()}.can_cast_to<A&&>(r));
CHECK(uarg{r, CXV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{CXV()}.cast<A>().f() == 1);
CHECK(uarg{CXV()}.cast<const A>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CXV()}.cast<A&>());
CHECK(uarg{CXV()}.cast<const A&>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CXV()}.cast<A&&>());
CHECK(uarg{CXV()}.cast<const A&&>().f() == 1);
CHECK(uarg{r, CXV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, CXV()}.cast<const A>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast<A&>(r));
CHECK(uarg{r, CXV()}.cast<const A&>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast<A&&>(r));
CHECK(uarg{r, CXV()}.cast<const A&&>(r).f() == 1);
CHECK(A::copy_ctors_ == 2);
CHECK(A::move_ctors_ == 0);
}
SUBCASE("PRV") {
CHECK(uarg{PRV()}.can_cast_to<A>());
CHECK(uarg{PRV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{PRV()}.can_cast_to<A&>());
CHECK(uarg{PRV()}.can_cast_to<const A&>());
CHECK(uarg{PRV()}.can_cast_to<A&&>());
CHECK(uarg{PRV()}.can_cast_to<const A&&>());
CHECK(uarg{r, PRV()}.can_cast_to<A>(r));
CHECK(uarg{r, PRV()}.can_cast_to<const A>(r));
CHECK_FALSE(uarg{r, PRV()}.can_cast_to<A&>(r));
CHECK(uarg{r, PRV()}.can_cast_to<const A&>(r));
CHECK(uarg{r, PRV()}.can_cast_to<A&&>(r));
CHECK(uarg{r, PRV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{PRV()}.cast<A>().f() == 1);
CHECK(uarg{PRV()}.cast<const A>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{PRV()}.cast<A&>());
CHECK(uarg{PRV()}.cast<const A&>().f() == 1);
CHECK(uarg{PRV()}.cast<A&&>().f() == 1);
CHECK(uarg{PRV()}.cast<const A&&>().f() == 1);
CHECK(uarg{r, PRV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, PRV()}.cast<const A>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast<A&>(r));
CHECK(uarg{r, PRV()}.cast<const A&>(r).f() == 1);
CHECK(uarg{r, PRV()}.cast<A&&>(r).f() == 1);
CHECK(uarg{r, PRV()}.cast<const A&&>(r).f() == 1);
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 2);
}
SUBCASE("CPRV") {
CHECK(uarg{CPRV()}.can_cast_to<A>());
CHECK(uarg{CPRV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{CPRV()}.can_cast_to<A&>());
CHECK(uarg{CPRV()}.can_cast_to<const A&>());
CHECK_FALSE(uarg{CPRV()}.can_cast_to<A&&>());
CHECK(uarg{CPRV()}.can_cast_to<const A&&>());
CHECK(uarg{r, CPRV()}.can_cast_to<A>(r));
CHECK(uarg{r, CPRV()}.can_cast_to<const A>(r));
CHECK_FALSE(uarg{r, CPRV()}.can_cast_to<A&>(r));
CHECK(uarg{r, CPRV()}.can_cast_to<const A&>(r));
CHECK_FALSE(uarg{r, CPRV()}.can_cast_to<A&&>(r));
CHECK(uarg{r, CPRV()}.can_cast_to<const A&&>(r));
CHECK(A::copy_ctors_ == 0);
CHECK(A::move_ctors_ == 0);
CHECK(uarg{CPRV()}.cast<A>().f() == 1);
CHECK(uarg{CPRV()}.cast<const A>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CPRV()}.cast<A&>());
CHECK(uarg{CPRV()}.cast<const A&>().f() == 1);
// CHECK_THROWS(std::ignore = uarg{CPRV()}.cast<A&&>());
CHECK(uarg{CPRV()}.cast<const A&&>().f() == 1);
CHECK(uarg{r, CPRV()}.cast<A>(r).f() == 1);
CHECK(uarg{r, CPRV()}.cast<const A>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast<A&>(r));
CHECK(uarg{r, CPRV()}.cast<const A&>(r).f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast<A&&>(r));
CHECK(uarg{r, CPRV()}.cast<const A&&>(r).f() == 1);
CHECK(A::copy_ctors_ == 2);
CHECK(A::move_ctors_ == 0);
}
SUBCASE("LV_PTR") {
CHECK(uarg{LV_PTR()}.can_cast_to<A*>());
CHECK(uarg{LV_PTR()}.can_cast_to<A* const>());
CHECK(uarg{LV_PTR()}.can_cast_to<const A*>());
CHECK(uarg{LV_PTR()}.can_cast_to<const A* const>());
CHECK(uarg{r, LV_PTR()}.can_cast_to<A*>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<const A* const>(r));
CHECK(uarg{LV_PTR()}.cast<A*>()->f() == 1);
CHECK(uarg{LV_PTR()}.cast<A* const>()->f() == 1);
CHECK(uarg{LV_PTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{LV_PTR()}.cast<const A* const>()->f() == 1);
CHECK(uarg{r, LV_PTR()}.cast<A*>(r)->f() == 1);
CHECK(uarg{r, LV_PTR()}.cast<A* const>(r)->f() == 1);
CHECK(uarg{r, LV_PTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, LV_PTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("LV_CPTR") {
CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to<A*>());
CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to<A* const>());
CHECK(uarg{LV_CPTR()}.can_cast_to<const A*>());
CHECK(uarg{LV_CPTR()}.can_cast_to<const A* const>());
CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to<A*>(r));
CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, LV_CPTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, LV_CPTR()}.can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast<A*>());
// CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast<A* const>());
CHECK(uarg{LV_CPTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{LV_CPTR()}.cast<const A* const>()->f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast<A*>(r));
// CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast<A* const>(r));
CHECK(uarg{r, LV_CPTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, LV_CPTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("CLV_PTR") {
CHECK(uarg{CLV_PTR()}.can_cast_to<A*>());
CHECK(uarg{CLV_PTR()}.can_cast_to<A* const>());
CHECK(uarg{CLV_PTR()}.can_cast_to<const A*>());
CHECK(uarg{CLV_PTR()}.can_cast_to<const A* const>());
CHECK(uarg{r, CLV_PTR()}.can_cast_to<A*>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<const A* const>(r));
CHECK(uarg{CLV_PTR()}.cast<A*>()->f() == 1);
CHECK(uarg{CLV_PTR()}.cast<A* const>()->f() == 1);
CHECK(uarg{CLV_PTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{CLV_PTR()}.cast<const A* const>()->f() == 1);
CHECK(uarg{r, CLV_PTR()}.cast<A*>(r)->f() == 1);
CHECK(uarg{r, CLV_PTR()}.cast<A* const>(r)->f() == 1);
CHECK(uarg{r, CLV_PTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, CLV_PTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("CLV_CPTR") {
CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to<A*>());
CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to<A* const>());
CHECK(uarg{CLV_CPTR()}.can_cast_to<const A*>());
CHECK(uarg{CLV_CPTR()}.can_cast_to<const A* const>());
CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to<A*>(r));
CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, CLV_CPTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, CLV_CPTR()}.can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast<A*>());
// CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast<A* const>());
CHECK(uarg{CLV_CPTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{CLV_CPTR()}.cast<const A* const>()->f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast<A*>(r));
// CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast<A* const>(r));
CHECK(uarg{r, CLV_CPTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, CLV_CPTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("XV_PTR") {
CHECK(uarg{XV_PTR()}.can_cast_to<A*>());
CHECK(uarg{XV_PTR()}.can_cast_to<A* const>());
CHECK(uarg{XV_PTR()}.can_cast_to<const A*>());
CHECK(uarg{XV_PTR()}.can_cast_to<const A* const>());
CHECK(uarg{r, XV_PTR()}.can_cast_to<A*>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<const A* const>(r));
CHECK(uarg{XV_PTR()}.cast<A*>()->f() == 1);
CHECK(uarg{XV_PTR()}.cast<A* const>()->f() == 1);
CHECK(uarg{XV_PTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{XV_PTR()}.cast<const A* const>()->f() == 1);
CHECK(uarg{r, XV_PTR()}.cast<A*>(r)->f() == 1);
CHECK(uarg{r, XV_PTR()}.cast<A* const>(r)->f() == 1);
CHECK(uarg{r, XV_PTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, XV_PTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("XV_CPTR") {
CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to<A*>());
CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to<A* const>());
CHECK(uarg{XV_CPTR()}.can_cast_to<const A*>());
CHECK(uarg{XV_CPTR()}.can_cast_to<const A* const>());
CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to<A*>(r));
CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, XV_CPTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, XV_CPTR()}.can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast<A*>());
// CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast<A* const>());
CHECK(uarg{XV_CPTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{XV_CPTR()}.cast<const A* const>()->f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast<A*>(r));
// CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast<A* const>(r));
CHECK(uarg{r, XV_CPTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, XV_CPTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("CXV_PTR") {
CHECK(uarg{CXV_PTR()}.can_cast_to<A*>());
CHECK(uarg{CXV_PTR()}.can_cast_to<A* const>());
CHECK(uarg{CXV_PTR()}.can_cast_to<const A*>());
CHECK(uarg{CXV_PTR()}.can_cast_to<const A* const>());
CHECK(uarg{r, CXV_PTR()}.can_cast_to<A*>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<const A* const>(r));
CHECK(uarg{CXV_PTR()}.cast<A*>()->f() == 1);
CHECK(uarg{CXV_PTR()}.cast<A* const>()->f() == 1);
CHECK(uarg{CXV_PTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{CXV_PTR()}.cast<const A* const>()->f() == 1);
CHECK(uarg{r, CXV_PTR()}.cast<A*>(r)->f() == 1);
CHECK(uarg{r, CXV_PTR()}.cast<A* const>(r)->f() == 1);
CHECK(uarg{r, CXV_PTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, CXV_PTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("CXV_CPTR") {
CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to<A*>());
CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to<A* const>());
CHECK(uarg{CXV_CPTR()}.can_cast_to<const A*>());
CHECK(uarg{CXV_CPTR()}.can_cast_to<const A* const>());
CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to<A*>(r));
CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, CXV_CPTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, CXV_CPTR()}.can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast<A*>());
// CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast<A* const>());
CHECK(uarg{CXV_CPTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{CXV_CPTR()}.cast<const A* const>()->f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast<A*>(r));
// CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast<A* const>(r));
CHECK(uarg{r, CXV_CPTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, CXV_CPTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("PRV_PTR") {
CHECK(uarg{PRV_PTR()}.can_cast_to<A*>());
CHECK(uarg{PRV_PTR()}.can_cast_to<A* const>());
CHECK(uarg{PRV_PTR()}.can_cast_to<const A*>());
CHECK(uarg{PRV_PTR()}.can_cast_to<const A* const>());
CHECK(uarg{r, PRV_PTR()}.can_cast_to<A*>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<const A* const>(r));
CHECK(uarg{PRV_PTR()}.cast<A*>()->f() == 1);
CHECK(uarg{PRV_PTR()}.cast<A* const>()->f() == 1);
CHECK(uarg{PRV_PTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{PRV_PTR()}.cast<const A* const>()->f() == 1);
CHECK(uarg{r, PRV_PTR()}.cast<A*>(r)->f() == 1);
CHECK(uarg{r, PRV_PTR()}.cast<A* const>(r)->f() == 1);
CHECK(uarg{r, PRV_PTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, PRV_PTR()}.cast<const A* const>(r)->f() == 1);
}
SUBCASE("PRV_CPTR") {
CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to<A*>());
CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to<A* const>());
CHECK(uarg{PRV_CPTR()}.can_cast_to<const A*>());
CHECK(uarg{PRV_CPTR()}.can_cast_to<const A* const>());
CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to<A*>(r));
CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to<A* const>(r));
CHECK(uarg{r, PRV_CPTR()}.can_cast_to<const A*>(r));
CHECK(uarg{r, PRV_CPTR()}.can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast<A*>());
// CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast<A* const>());
CHECK(uarg{PRV_CPTR()}.cast<const A*>()->f() == 1);
CHECK(uarg{PRV_CPTR()}.cast<const A* const>()->f() == 1);
// CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast<A*>(r));
// CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast<A* const>(r));
CHECK(uarg{r, PRV_CPTR()}.cast<const A*>(r)->f() == 1);
CHECK(uarg{r, PRV_CPTR()}.cast<const A* const>(r)->f() == 1);
}
}

50
develop/untests/meta_utilities/arg3_tests.cpp
View File

@@ -54,6 +54,8 @@ TEST_CASE("meta/meta_utilities/arg3") {
TEST_CASE("meta/meta_utilities/arg3/cast") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
auto LV = []() -> D& { static D v; return v; };
auto CLV = []() -> const D& { static D v; return v; };
@@ -79,50 +81,50 @@ TEST_CASE("meta/meta_utilities/arg3/cast") {
// *------------------------------------------------------------*
SUBCASE("LV") {
CHECK_FALSE(uarg{LV()}.can_cast_to<A>());
CHECK_FALSE(uarg{LV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, LV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, LV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{LV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{LV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, LV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, LV()}.cast<const A>(r));
}
SUBCASE("CLV") {
CHECK_FALSE(uarg{CLV()}.can_cast_to<A>());
CHECK_FALSE(uarg{CLV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, CLV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, CLV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{CLV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{CLV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast<const A>(r));
}
SUBCASE("XV") {
CHECK_FALSE(uarg{XV()}.can_cast_to<A>());
CHECK_FALSE(uarg{XV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, XV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, XV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{XV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{XV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, XV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, XV()}.cast<const A>(r));
}
SUBCASE("CXV") {
CHECK_FALSE(uarg{CXV()}.can_cast_to<A>());
CHECK_FALSE(uarg{CXV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, CXV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, CXV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{CXV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{CXV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast<const A>(r));
}
SUBCASE("PRV") {
CHECK_FALSE(uarg{PRV()}.can_cast_to<A>());
CHECK_FALSE(uarg{PRV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, PRV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, PRV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{PRV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{PRV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast<const A>(r));
}
SUBCASE("CPRV") {
CHECK_FALSE(uarg{CPRV()}.can_cast_to<A>());
CHECK_FALSE(uarg{CPRV()}.can_cast_to<const A>());
CHECK_FALSE(uarg{r, CPRV()}.can_cast_to<A>(r));
CHECK_FALSE(uarg{r, CPRV()}.can_cast_to<const A>(r));
// CHECK_THROWS(std::ignore = uarg{CPRV()}.cast<A>());
// CHECK_THROWS(std::ignore = uarg{CPRV()}.cast<const A>());
// CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast<A>(r));
// CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast<const A>(r));
}
}

162
develop/untests/meta_utilities/arg4_tests.cpp
View File

@@ -10,6 +10,8 @@
TEST_CASE("meta/meta_utilities/arg4/cast") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
auto LV_PTR = []() -> int*& { static int v{42}; static int* p{&v}; return p; };
auto CLV_PTR = []() -> int* const& { static int v{42}; static int* p{&v}; return p; };
@@ -24,122 +26,122 @@ TEST_CASE("meta/meta_utilities/arg4/cast") {
auto PRV_CPTR = []() -> const int* { static int v{42}; static const int* p{&v}; return p; };
SUBCASE("LV_PTR") {
CHECK(uarg{LV_PTR()}.can_cast_to<int*>());
CHECK(uarg{LV_PTR()}.can_cast_to<int* const>());
CHECK(uarg{LV_PTR()}.can_cast_to<const int*>());
CHECK(uarg{LV_PTR()}.can_cast_to<const int* const>());
CHECK(uarg{r, LV_PTR()}.can_cast_to<int*>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, LV_PTR()}.can_cast_to<const int* const>(r));
CHECK(*uarg{LV_PTR()}.cast<int*>() == 42);
CHECK(*uarg{LV_PTR()}.cast<int* const>() == 42);
CHECK(*uarg{LV_PTR()}.cast<const int*>() == 42);
CHECK(*uarg{LV_PTR()}.cast<const int* const>() == 42);
CHECK(*uarg{r, LV_PTR()}.cast<int*>(r) == 42);
CHECK(*uarg{r, LV_PTR()}.cast<int* const>(r) == 42);
CHECK(*uarg{r, LV_PTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, LV_PTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("CLV_PTR") {
CHECK(uarg{CLV_PTR()}.can_cast_to<int*>());
CHECK(uarg{CLV_PTR()}.can_cast_to<int* const>());
CHECK(uarg{CLV_PTR()}.can_cast_to<const int*>());
CHECK(uarg{CLV_PTR()}.can_cast_to<const int* const>());
CHECK(uarg{r, CLV_PTR()}.can_cast_to<int*>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, CLV_PTR()}.can_cast_to<const int* const>(r));
CHECK(*uarg{CLV_PTR()}.cast<int*>() == 42);
CHECK(*uarg{CLV_PTR()}.cast<int* const>() == 42);
CHECK(*uarg{CLV_PTR()}.cast<const int*>() == 42);
CHECK(*uarg{CLV_PTR()}.cast<const int* const>() == 42);
CHECK(*uarg{r, CLV_PTR()}.cast<int*>(r) == 42);
CHECK(*uarg{r, CLV_PTR()}.cast<int* const>(r) == 42);
CHECK(*uarg{r, CLV_PTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, CLV_PTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("XV_PTR") {
CHECK(uarg{XV_PTR()}.can_cast_to<int*>());
CHECK(uarg{XV_PTR()}.can_cast_to<int* const>());
CHECK(uarg{XV_PTR()}.can_cast_to<const int*>());
CHECK(uarg{XV_PTR()}.can_cast_to<const int* const>());
CHECK(uarg{r, XV_PTR()}.can_cast_to<int*>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, XV_PTR()}.can_cast_to<const int* const>(r));
CHECK(*uarg{XV_PTR()}.cast<int*>() == 42);
CHECK(*uarg{XV_PTR()}.cast<int* const>() == 42);
CHECK(*uarg{XV_PTR()}.cast<const int*>() == 42);
CHECK(*uarg{XV_PTR()}.cast<const int* const>() == 42);
CHECK(*uarg{r, XV_PTR()}.cast<int*>(r) == 42);
CHECK(*uarg{r, XV_PTR()}.cast<int* const>(r) == 42);
CHECK(*uarg{r, XV_PTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, XV_PTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("CXV_PTR") {
CHECK(uarg{CXV_PTR()}.can_cast_to<int*>());
CHECK(uarg{CXV_PTR()}.can_cast_to<int* const>());
CHECK(uarg{CXV_PTR()}.can_cast_to<const int*>());
CHECK(uarg{CXV_PTR()}.can_cast_to<const int* const>());
CHECK(uarg{r, CXV_PTR()}.can_cast_to<int*>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, CXV_PTR()}.can_cast_to<const int* const>(r));
CHECK(*uarg{CXV_PTR()}.cast<int*>() == 42);
CHECK(*uarg{CXV_PTR()}.cast<int* const>() == 42);
CHECK(*uarg{CXV_PTR()}.cast<const int*>() == 42);
CHECK(*uarg{CXV_PTR()}.cast<const int* const>() == 42);
CHECK(*uarg{r, CXV_PTR()}.cast<int*>(r) == 42);
CHECK(*uarg{r, CXV_PTR()}.cast<int* const>(r) == 42);
CHECK(*uarg{r, CXV_PTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, CXV_PTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("PRV_PTR") {
CHECK(uarg{PRV_PTR()}.can_cast_to<int*>());
CHECK(uarg{PRV_PTR()}.can_cast_to<int* const>());
CHECK(uarg{PRV_PTR()}.can_cast_to<const int*>());
CHECK(uarg{PRV_PTR()}.can_cast_to<const int* const>());
CHECK(uarg{r, PRV_PTR()}.can_cast_to<int*>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, PRV_PTR()}.can_cast_to<const int* const>(r));
CHECK(*uarg{PRV_PTR()}.cast<int*>() == 42);
CHECK(*uarg{PRV_PTR()}.cast<int* const>() == 42);
CHECK(*uarg{PRV_PTR()}.cast<const int*>() == 42);
CHECK(*uarg{PRV_PTR()}.cast<const int* const>() == 42);
CHECK(*uarg{r, PRV_PTR()}.cast<int*>(r) == 42);
CHECK(*uarg{r, PRV_PTR()}.cast<int* const>(r) == 42);
CHECK(*uarg{r, PRV_PTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, PRV_PTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("LV_CPTR") {
CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to<int*>());
CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to<int* const>());
CHECK(uarg{LV_CPTR()}.can_cast_to<const int*>());
CHECK(uarg{LV_CPTR()}.can_cast_to<const int* const>());
CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to<int*>(r));
CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, LV_CPTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, LV_CPTR()}.can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast<int*>());
// CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast<int* const>());
CHECK(*uarg{LV_CPTR()}.cast<const int*>() == 42);
CHECK(*uarg{LV_CPTR()}.cast<const int* const>() == 42);
// CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast<int*>(r));
// CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast<int* const>(r));
CHECK(*uarg{r, LV_CPTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, LV_CPTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("CLV_CPTR") {
CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to<int*>());
CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to<int* const>());
CHECK(uarg{CLV_CPTR()}.can_cast_to<const int*>());
CHECK(uarg{CLV_CPTR()}.can_cast_to<const int* const>());
CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to<int*>(r));
CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, CLV_CPTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, CLV_CPTR()}.can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast<int*>());
// CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast<int* const>());
CHECK(*uarg{CLV_CPTR()}.cast<const int*>() == 42);
CHECK(*uarg{CLV_CPTR()}.cast<const int* const>() == 42);
// CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast<int*>(r));
// CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast<int* const>(r));
CHECK(*uarg{r, CLV_CPTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, CLV_CPTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("XV_CPTR") {
CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to<int*>());
CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to<int* const>());
CHECK(uarg{XV_CPTR()}.can_cast_to<const int*>());
CHECK(uarg{XV_CPTR()}.can_cast_to<const int* const>());
CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to<int*>(r));
CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, XV_CPTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, XV_CPTR()}.can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast<int*>());
// CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast<int* const>());
CHECK(*uarg{XV_CPTR()}.cast<const int*>() == 42);
CHECK(*uarg{XV_CPTR()}.cast<const int* const>() == 42);
// CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast<int*>(r));
// CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast<int* const>(r));
CHECK(*uarg{r, XV_CPTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, XV_CPTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("CXV_CPTR") {
CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to<int*>());
CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to<int* const>());
CHECK(uarg{CXV_CPTR()}.can_cast_to<const int*>());
CHECK(uarg{CXV_CPTR()}.can_cast_to<const int* const>());
CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to<int*>(r));
CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, CXV_CPTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, CXV_CPTR()}.can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast<int*>());
// CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast<int* const>());
CHECK(*uarg{CXV_CPTR()}.cast<const int*>() == 42);
CHECK(*uarg{CXV_CPTR()}.cast<const int* const>() == 42);
// CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast<int*>(r));
// CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast<int* const>(r));
CHECK(*uarg{r, CXV_CPTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, CXV_CPTR()}.cast<const int* const>(r) == 42);
}
SUBCASE("PRV_CPTR") {
CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to<int*>());
CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to<int* const>());
CHECK(uarg{PRV_CPTR()}.can_cast_to<const int*>());
CHECK(uarg{PRV_CPTR()}.can_cast_to<const int* const>());
CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to<int*>(r));
CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to<int* const>(r));
CHECK(uarg{r, PRV_CPTR()}.can_cast_to<const int*>(r));
CHECK(uarg{r, PRV_CPTR()}.can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast<int*>());
// CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast<int* const>());
CHECK(*uarg{PRV_CPTR()}.cast<const int*>() == 42);
CHECK(*uarg{PRV_CPTR()}.cast<const int* const>() == 42);
// CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast<int*>(r));
// CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast<int* const>(r));
CHECK(*uarg{r, PRV_CPTR()}.cast<const int*>(r) == 42);
CHECK(*uarg{r, PRV_CPTR()}.cast<const int* const>(r) == 42);
}
}

162
develop/untests/meta_utilities/arg5_tests.cpp
View File

@@ -50,85 +50,87 @@ TEST_CASE("meta/meta_utilities/arg5") {
TEST_CASE("meta/meta_utilities/arg5/cast") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
SUBCASE("int[2]") {
int arr[2]{1,2};
CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr));
CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr));
static_assert(std::is_invocable_v<void(int*), int (&) [2]>);
static_assert(std::is_invocable_v<void(const int*), int (&) [2]>);
static_assert(std::is_invocable_v<void(int* const), int (&) [2]>);
static_assert(std::is_invocable_v<void(const int* const), int (&) [2]>);
CHECK(uarg(arr).can_cast_to<int*>());
CHECK(uarg(arr).can_cast_to<const int*>());
CHECK(uarg(arr).can_cast_to<int* const>());
CHECK(uarg(arr).can_cast_to<const int* const>());
CHECK(uarg(r, arr).can_cast_to<int*>(r));
CHECK(uarg(r, arr).can_cast_to<const int*>(r));
CHECK(uarg(r, arr).can_cast_to<int* const>(r));
CHECK(uarg(r, arr).can_cast_to<const int* const>(r));
CHECK(uarg(arr).cast<int*>() == static_cast<int*>(arr));
CHECK(uarg(arr).cast<const int*>() == static_cast<const int*>(arr));
CHECK(uarg(arr).cast<int* const>() == static_cast<int*>(arr));
CHECK(uarg(arr).cast<const int* const>() == static_cast<const int*>(arr));
CHECK(uarg(r, arr).cast<int*>(r) == static_cast<int*>(arr));
CHECK(uarg(r, arr).cast<const int*>(r) == static_cast<const int*>(arr));
CHECK(uarg(r, arr).cast<int* const>(r) == static_cast<int*>(arr));
CHECK(uarg(r, arr).cast<const int* const>(r) == static_cast<const int*>(arr));
}
SUBCASE("const int[2]") {
const int arr[2]{1,2};
CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr));
CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr));
static_assert(!std::is_invocable_v<void(int*), const int (&) [2]>);
static_assert(std::is_invocable_v<void(const int*), const int (&) [2]>);
static_assert(!std::is_invocable_v<void(int* const), const int (&) [2]>);
static_assert(std::is_invocable_v<void(const int* const), const int (&) [2]>);
CHECK_FALSE(uarg(arr).can_cast_to<int*>());
CHECK(uarg(arr).can_cast_to<const int*>());
CHECK_FALSE(uarg(arr).can_cast_to<int* const>());
CHECK(uarg(arr).can_cast_to<const int* const>());
CHECK_FALSE(uarg(r, arr).can_cast_to<int*>(r));
CHECK(uarg(r, arr).can_cast_to<const int*>(r));
CHECK_FALSE(uarg(r, arr).can_cast_to<int* const>(r));
CHECK(uarg(r, arr).can_cast_to<const int* const>(r));
// CHECK_THROWS(std::ignore = uarg(arr).cast<int*>());
CHECK(uarg(arr).cast<const int*>() == static_cast<const int*>(arr));
// CHECK_THROWS(std::ignore = uarg(arr).cast<int* const>());
CHECK(uarg(arr).cast<const int* const>() == static_cast<const int*>(arr));
// CHECK_THROWS(std::ignore = uarg(r, arr).cast<int*>(r));
CHECK(uarg(r, arr).cast<const int*>(r) == static_cast<const int*>(arr));
// CHECK_THROWS(std::ignore = uarg(r, arr).cast<int* const>(r));
CHECK(uarg(r, arr).cast<const int* const>(r) == static_cast<const int*>(arr));
}
SUBCASE("D[2]") {
D arr[2];
CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr));
CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr));
static_assert(std::is_invocable_v<void(A*), D (&) [2]>);
static_assert(std::is_invocable_v<void(const A*), D (&) [2]>);
static_assert(std::is_invocable_v<void(A* const), D (&) [2]>);
static_assert(std::is_invocable_v<void(const A* const), D (&) [2]>);
CHECK(uarg(arr).can_cast_to<A*>());
CHECK(uarg(arr).can_cast_to<const A*>());
CHECK(uarg(arr).can_cast_to<A* const>());
CHECK(uarg(arr).can_cast_to<const A* const>());
CHECK(uarg(r, arr).can_cast_to<A*>(r));
CHECK(uarg(r, arr).can_cast_to<const A*>(r));
CHECK(uarg(r, arr).can_cast_to<A* const>(r));
CHECK(uarg(r, arr).can_cast_to<const A* const>(r));
CHECK(uarg(arr).cast<A*>() == static_cast<A*>(arr));
CHECK(uarg(arr).cast<const A*>() == static_cast<const A*>(arr));
CHECK(uarg(arr).cast<A* const>() == static_cast<A*>(arr));
CHECK(uarg(arr).cast<const A* const>() == static_cast<const A*>(arr));
CHECK(uarg(r, arr).cast<A*>(r) == static_cast<A*>(arr));
CHECK(uarg(r, arr).cast<const A*>(r) == static_cast<const A*>(arr));
CHECK(uarg(r, arr).cast<A* const>(r) == static_cast<A*>(arr));
CHECK(uarg(r, arr).cast<const A* const>(r) == static_cast<const A*>(arr));
}
SUBCASE("const D[2]") {
const D arr[2];
CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr));
CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr));
static_assert(!std::is_invocable_v<void(A*), const D (&) [2]>);
static_assert(std::is_invocable_v<void(const A*), const D (&) [2]>);
static_assert(!std::is_invocable_v<void(A* const), const D (&) [2]>);
static_assert(std::is_invocable_v<void(const A* const), const D (&) [2]>);
CHECK_FALSE(uarg(arr).can_cast_to<A*>());
CHECK(uarg(arr).can_cast_to<const A*>());
CHECK_FALSE(uarg(arr).can_cast_to<A* const>());
CHECK(uarg(arr).can_cast_to<const A* const>());
CHECK_FALSE(uarg(r, arr).can_cast_to<A*>(r));
CHECK(uarg(r, arr).can_cast_to<const A*>(r));
CHECK_FALSE(uarg(r, arr).can_cast_to<A* const>(r));
CHECK(uarg(r, arr).can_cast_to<const A* const>(r));
// CHECK_THROWS(std::ignore = uarg(arr).cast<A*>());
CHECK(uarg(arr).cast<const A*>() == static_cast<const A*>(arr));
// CHECK_THROWS(std::ignore = uarg(arr).cast<A* const>());
CHECK(uarg(arr).cast<const A* const>() == static_cast<const A*>(arr));
// CHECK_THROWS(std::ignore = uarg(r, arr).cast<A*>(r));
CHECK(uarg(r, arr).cast<const A*>(r) == static_cast<const A*>(arr));
// CHECK_THROWS(std::ignore = uarg(r, arr).cast<A* const>(r));
CHECK(uarg(r, arr).cast<const A* const>(r) == static_cast<const A*>(arr));
}
SUBCASE("&") {
@@ -137,7 +139,7 @@ TEST_CASE("meta/meta_utilities/arg5/cast") {
{
auto LV = []() -> T& { return src; };
CHECK(uarg{LV()}.get_raw_type() == meta::resolve_type<D[2]>());
CHECK(uarg{r, LV()}.get_raw_type() == meta::resolve_type<D[2]>());
static_assert(std::is_invocable_v<void(A*), decltype(LV())>);
static_assert(std::is_invocable_v<void(const A*), decltype(LV())>);
@@ -149,55 +151,55 @@ TEST_CASE("meta/meta_utilities/arg5/cast") {
[](A* const){}(LV());
[](const A* const){}(LV());
CHECK(uarg(LV()).cast<A*>() == static_cast<A*>(src));
CHECK(uarg(LV()).cast<const A*>() == static_cast<const A*>(src));
CHECK(uarg(LV()).cast<A* const>() == static_cast<A*>(src));
CHECK(uarg(LV()).cast<const A* const>() == static_cast<const A*>(src));
CHECK(uarg(r, LV()).cast<A*>(r) == static_cast<A*>(src));
CHECK(uarg(r, LV()).cast<const A*>(r) == static_cast<const A*>(src));
CHECK(uarg(r, LV()).cast<A* const>(r) == static_cast<A*>(src));
CHECK(uarg(r, LV()).cast<const A* const>(r) == static_cast<const A*>(src));
}
{
auto CLV = []() -> const T& { return src; };
CHECK(uarg{CLV()}.get_raw_type() == meta::resolve_type<D[2]>());
CHECK(uarg{r, CLV()}.get_raw_type() == meta::resolve_type<D[2]>());
static_assert(!std::is_invocable_v<void(A*), decltype(CLV())>);
static_assert(std::is_invocable_v<void(const A*), decltype(CLV())>);
static_assert(!std::is_invocable_v<void(A* const), decltype(CLV())>);
static_assert(std::is_invocable_v<void(const A* const), decltype(CLV())>);
// CHECK_THROWS(std::ignore = uarg(CLV()).cast<A*>());
CHECK(uarg(CLV()).cast<const A*>() == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(CLV()).cast<A* const>());
CHECK(uarg(CLV()).cast<const A* const>() == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(r, CLV()).cast<A*>(r));
CHECK(uarg(r, CLV()).cast<const A*>(r) == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(r, CLV()).cast<A* const>(r));
CHECK(uarg(r, CLV()).cast<const A* const>(r) == static_cast<const A*>(src));
}
{
auto XV = []() -> T&& { return std::move(src); };
CHECK(uarg{XV()}.get_raw_type() == meta::resolve_type<D[2]>());
CHECK(uarg{r, XV()}.get_raw_type() == meta::resolve_type<D[2]>());
static_assert(std::is_invocable_v<void(A*), decltype(XV())>);
static_assert(std::is_invocable_v<void(const A*), decltype(XV())>);
static_assert(std::is_invocable_v<void(A* const), decltype(XV())>);
static_assert(std::is_invocable_v<void(const A* const), decltype(XV())>);
CHECK(uarg(XV()).cast<A*>() == static_cast<A*>(src));
CHECK(uarg(XV()).cast<const A*>() == static_cast<const A*>(src));
CHECK(uarg(XV()).cast<A* const>() == static_cast<A*>(src));
CHECK(uarg(XV()).cast<const A* const>() == static_cast<const A*>(src));
CHECK(uarg(r, XV()).cast<A*>(r) == static_cast<A*>(src));
CHECK(uarg(r, XV()).cast<const A*>(r) == static_cast<const A*>(src));
CHECK(uarg(r, XV()).cast<A* const>(r) == static_cast<A*>(src));
CHECK(uarg(r, XV()).cast<const A* const>(r) == static_cast<const A*>(src));
}
{
auto CXV = []() -> const T&& { return std::move(src); };
CHECK(uarg{CXV()}.get_raw_type() == meta::resolve_type<D[2]>());
CHECK(uarg{r, CXV()}.get_raw_type() == meta::resolve_type<D[2]>());
static_assert(!std::is_invocable_v<void(A*), decltype(CXV())>);
static_assert(std::is_invocable_v<void(const A*), decltype(CXV())>);
static_assert(!std::is_invocable_v<void(A* const), decltype(CXV())>);
static_assert(std::is_invocable_v<void(const A* const), decltype(CXV())>);
// CHECK_THROWS(std::ignore = uarg(CXV()).cast<A*>());
CHECK(uarg(CXV()).cast<const A*>() == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(CXV()).cast<A* const>());
CHECK(uarg(CXV()).cast<const A* const>() == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(r, CXV()).cast<A*>(r));
CHECK(uarg(r, CXV()).cast<const A*>(r) == static_cast<const A*>(src));
// CHECK_THROWS(std::ignore = uarg(r, CXV()).cast<A* const>(r));
CHECK(uarg(r, CXV()).cast<const A* const>(r) == static_cast<const A*>(src));
}
}
@@ -212,19 +214,19 @@ TEST_CASE("meta/meta_utilities/arg5/cast") {
static_assert(std::is_invocable_v<void(D (* const) [2]), D (*) [2]>);
static_assert(std::is_invocable_v<void(const D (* const) [2]), D (*) [2]>);
CHECK(uarg{arr}.can_cast_to<D (&) [2]>());
CHECK(uarg{arr}.can_cast_to<const D (&) [2]>());
CHECK(uarg{&arr}.can_cast_to<D (*) [2]>());
CHECK(uarg{&arr}.can_cast_to<const D (*) [2]>());
CHECK(uarg{&arr}.can_cast_to<D (* const) [2]>());
CHECK(uarg{&arr}.can_cast_to<const D (* const) [2]>());
CHECK(uarg{r, arr}.can_cast_to<D (&) [2]>(r));
CHECK(uarg{r, arr}.can_cast_to<const D (&) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<D (*) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<const D (*) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<D (* const) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<const D (* const) [2]>(r));
CHECK(&uarg{arr}.cast<D (&) [2]>() == &arr);
CHECK(&uarg{arr}.cast<const D (&) [2]>() == &arr);
CHECK(uarg{&arr}.cast<D (*) [2]>() == &arr);
CHECK(uarg{&arr}.cast<const D (*) [2]>() == &arr);
CHECK(uarg{&arr}.cast<D (* const) [2]>() == &arr);
CHECK(uarg{&arr}.cast<const D (* const) [2]>() == &arr);
CHECK(&uarg{r, arr}.cast<D (&) [2]>(r) == &arr);
CHECK(&uarg{r, arr}.cast<const D (&) [2]>(r) == &arr);
CHECK(uarg{r, &arr}.cast<D (*) [2]>(r) == &arr);
CHECK(uarg{r, &arr}.cast<const D (*) [2]>(r) == &arr);
CHECK(uarg{r, &arr}.cast<D (* const) [2]>(r) == &arr);
CHECK(uarg{r, &arr}.cast<const D (* const) [2]>(r) == &arr);
}
{
@@ -237,19 +239,19 @@ TEST_CASE("meta/meta_utilities/arg5/cast") {
static_assert(!std::is_invocable_v<void(D (* const) [2]), const D (*) [2]>);
static_assert(std::is_invocable_v<void(const D (* const) [2]), const D (*) [2]>);
CHECK_FALSE(uarg{arr}.can_cast_to<D (&) [2]>());
CHECK(uarg{arr}.can_cast_to<const D (&) [2]>());
CHECK_FALSE(uarg{&arr}.can_cast_to<D (*) [2]>());
CHECK(uarg{&arr}.can_cast_to<const D (*) [2]>());
CHECK_FALSE(uarg{&arr}.can_cast_to<D (* const) [2]>());
CHECK(uarg{&arr}.can_cast_to<const D (* const) [2]>());
CHECK_FALSE(uarg{r, arr}.can_cast_to<D (&) [2]>(r));
CHECK(uarg{r, arr}.can_cast_to<const D (&) [2]>(r));
CHECK_FALSE(uarg{r, &arr}.can_cast_to<D (*) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<const D (*) [2]>(r));
CHECK_FALSE(uarg{r, &arr}.can_cast_to<D (* const) [2]>(r));
CHECK(uarg{r, &arr}.can_cast_to<const D (* const) [2]>(r));
// CHECK_THROWS(std::ignore = &uarg{arr}.cast<D (&) [2]>());
CHECK(&uarg{arr}.cast<const D (&) [2]>() == &arr);
// CHECK_THROWS(std::ignore = uarg{&arr}.cast<D (*) [2]>());
CHECK(uarg{&arr}.cast<const D (*) [2]>() == &arr);
// CHECK_THROWS(std::ignore = uarg{&arr}.cast<D (* const) [2]>());
CHECK(uarg{&arr}.cast<const D (* const) [2]>() == &arr);
// CHECK_THROWS(std::ignore = &uarg{r, arr}.cast<D (&) [2]>(r));
CHECK(&uarg{r, arr}.cast<const D (&) [2]>(r) == &arr);
// CHECK_THROWS(std::ignore = uarg{r, &arr}.cast<D (*) [2]>(r));
CHECK(uarg{r, &arr}.cast<const D (*) [2]>(r) == &arr);
// CHECK_THROWS(std::ignore = uarg{r, &arr}.cast<D (* const) [2]>(r));
CHECK(uarg{r, &arr}.cast<const D (* const) [2]>(r) == &arr);
}
}
}

116
develop/untests/meta_utilities/arg7_tests.cpp
View File

@@ -50,6 +50,8 @@ TEST_CASE("meta/meta_utilities/arg7") {
TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
SUBCASE("int* -> void*") {
int i{42};
@@ -57,11 +59,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(std::is_invocable_v<void(void*), int*>);
static_assert(std::is_invocable_v<void(const void*), int*>);
CHECK(uarg{&i}.can_cast_to<void*>());
CHECK(uarg{&i}.can_cast_to<const void*>());
CHECK(uarg{r, &i}.can_cast_to<void*>(r));
CHECK(uarg{r, &i}.can_cast_to<const void*>(r));
CHECK(uarg{&i}.cast<void*>() == &i);
CHECK(uarg{&i}.cast<const void*>() == &i);
CHECK(uarg{r, &i}.cast<void*>(r) == &i);
CHECK(uarg{r, &i}.cast<const void*>(r) == &i);
}
SUBCASE("const int* -> void*") {
@@ -70,11 +72,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(!std::is_invocable_v<void(void*), const int*>);
static_assert(std::is_invocable_v<void(const void*), const int*>);
CHECK_FALSE(uarg{&i}.can_cast_to<void*>());
CHECK(uarg{&i}.can_cast_to<const void*>());
CHECK_FALSE(uarg{r, &i}.can_cast_to<void*>(r));
CHECK(uarg{r, &i}.can_cast_to<const void*>(r));
// CHECK_THROWS(std::ignore = uarg{&i}.cast<void*>());
CHECK(uarg{&i}.cast<const void*>() == &i);
// CHECK_THROWS(std::ignore = uarg{r, &i}.cast<void*>(r));
CHECK(uarg{r, &i}.cast<const void*>(r) == &i);
}
SUBCASE("D* -> void*") {
@@ -83,11 +85,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(std::is_invocable_v<void(void*), D*>);
static_assert(std::is_invocable_v<void(const void*), D*>);
CHECK(uarg{&d}.can_cast_to<void*>());
CHECK(uarg{&d}.can_cast_to<const void*>());
CHECK(uarg{r, &d}.can_cast_to<void*>(r));
CHECK(uarg{r, &d}.can_cast_to<const void*>(r));
CHECK(uarg{&d}.cast<void*>() == &d);
CHECK(uarg{&d}.cast<const void*>() == &d);
CHECK(uarg{r, &d}.cast<void*>(r) == &d);
CHECK(uarg{r, &d}.cast<const void*>(r) == &d);
}
SUBCASE("const D* -> void*") {
@@ -96,11 +98,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(!std::is_invocable_v<void(void*), const D*>);
static_assert(std::is_invocable_v<void(const void*), const D*>);
CHECK_FALSE(uarg{&d}.can_cast_to<void*>());
CHECK(uarg{&d}.can_cast_to<const void*>());
CHECK_FALSE(uarg{r, &d}.can_cast_to<void*>(r));
CHECK(uarg{r, &d}.can_cast_to<const void*>(r));
// CHECK_THROWS(std::ignore = uarg{&d}.cast<void*>());
CHECK(uarg{&d}.cast<const void*>() == &d);
// CHECK_THROWS(std::ignore = uarg{r, &d}.cast<void*>(r));
CHECK(uarg{r, &d}.cast<const void*>(r) == &d);
}
SUBCASE("D[2] -> void*") {
@@ -109,11 +111,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(std::is_invocable_v<void(void*), D (&) [2]>);
static_assert(std::is_invocable_v<void(const void*), D (&) [2]>);
CHECK(uarg{arr}.can_cast_to<void*>());
CHECK(uarg{arr}.can_cast_to<const void*>());
CHECK(uarg{r, arr}.can_cast_to<void*>(r));
CHECK(uarg{r, arr}.can_cast_to<const void*>(r));
CHECK(uarg{arr}.cast<void*>() == &arr);
CHECK(uarg{arr}.cast<const void*>() == &arr);
CHECK(uarg{r, arr}.cast<void*>(r) == &arr);
CHECK(uarg{r, arr}.cast<const void*>(r) == &arr);
}
SUBCASE("const D[2] -> void*") {
@@ -122,17 +124,19 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") {
static_assert(!std::is_invocable_v<void(void*), const D (&) [2]>);
static_assert(std::is_invocable_v<void(const void*), const D (&) [2]>);
CHECK_FALSE(uarg{arr}.can_cast_to<void*>());
CHECK(uarg{arr}.can_cast_to<const void*>());
CHECK_FALSE(uarg{r, arr}.can_cast_to<void*>(r));
CHECK(uarg{r, arr}.can_cast_to<const void*>(r));
// CHECK_THROWS(std::ignore = uarg{arr}.cast<void*>());
CHECK(uarg{arr}.cast<const void*>() == &arr);
// CHECK_THROWS(std::ignore = uarg{r, arr}.cast<void*>(r));
CHECK(uarg{r, arr}.cast<const void*>(r) == &arr);
}
}
TEST_CASE("meta/meta_utilities/arg7/cast/from_nullptr") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
SUBCASE("nullptr -> *") {
static_assert(std::is_invocable_v<void(int*), std::nullptr_t>);
@@ -152,46 +156,46 @@ TEST_CASE("meta/meta_utilities/arg7/cast/from_nullptr") {
std::nullptr_t n1{nullptr};
const std::nullptr_t n2{nullptr};
CHECK(uarg{n1}.can_cast_to<int*>());
CHECK(uarg{std::move(n1)}.can_cast_to<int*>());
CHECK(uarg{n2}.can_cast_to<int*>());
CHECK(uarg{std::move(n2)}.can_cast_to<int*>());
CHECK(uarg{r, n1}.can_cast_to<int*>(r));
CHECK(uarg{r, std::move(n1)}.can_cast_to<int*>(r));
CHECK(uarg{r, n2}.can_cast_to<int*>(r));
CHECK(uarg{r, std::move(n2)}.can_cast_to<int*>(r));
CHECK(uarg{n1}.can_cast_to<const int*>());
CHECK(uarg{std::move(n1)}.can_cast_to<const int*>());
CHECK(uarg{n2}.can_cast_to<const int*>());
CHECK(uarg{std::move(n2)}.can_cast_to<const int*>());
CHECK(uarg{r, n1}.can_cast_to<const int*>(r));
CHECK(uarg{r, std::move(n1)}.can_cast_to<const int*>(r));
CHECK(uarg{r, n2}.can_cast_to<const int*>(r));
CHECK(uarg{r, std::move(n2)}.can_cast_to<const int*>(r));
CHECK(uarg{n1}.can_cast_to<D*>());
CHECK(uarg{std::move(n1)}.can_cast_to<D*>());
CHECK(uarg{n2}.can_cast_to<D*>());
CHECK(uarg{std::move(n2)}.can_cast_to<D*>());
CHECK(uarg{r, n1}.can_cast_to<D*>(r));
CHECK(uarg{r, std::move(n1)}.can_cast_to<D*>(r));
CHECK(uarg{r, n2}.can_cast_to<D*>(r));
CHECK(uarg{r, std::move(n2)}.can_cast_to<D*>(r));
CHECK(uarg{n1}.can_cast_to<const D*>());
CHECK(uarg{std::move(n1)}.can_cast_to<const D*>());
CHECK(uarg{n2}.can_cast_to<const D*>());
CHECK(uarg{std::move(n2)}.can_cast_to<const D*>());
CHECK(uarg{r, n1}.can_cast_to<const D*>(r));
CHECK(uarg{r, std::move(n1)}.can_cast_to<const D*>(r));
CHECK(uarg{r, n2}.can_cast_to<const D*>(r));
CHECK(uarg{r, std::move(n2)}.can_cast_to<const D*>(r));
//
CHECK(uarg{n1}.cast<int*>() == nullptr);
CHECK(uarg{std::move(n1)}.cast<int*>() == nullptr);
CHECK(uarg{n2}.cast<int*>() == nullptr);
CHECK(uarg{std::move(n2)}.cast<int*>() == nullptr);
CHECK(uarg{r, n1}.cast<int*>(r) == nullptr);
CHECK(uarg{r, std::move(n1)}.cast<int*>(r) == nullptr);
CHECK(uarg{r, n2}.cast<int*>(r) == nullptr);
CHECK(uarg{r, std::move(n2)}.cast<int*>(r) == nullptr);
CHECK(uarg{n1}.cast<const int*>() == nullptr);
CHECK(uarg{std::move(n1)}.cast<const int*>() == nullptr);
CHECK(uarg{n2}.cast<const int*>() == nullptr);
CHECK(uarg{std::move(n2)}.cast<const int*>() == nullptr);
CHECK(uarg{r, n1}.cast<const int*>(r) == nullptr);
CHECK(uarg{r, std::move(n1)}.cast<const int*>(r) == nullptr);
CHECK(uarg{r, n2}.cast<const int*>(r) == nullptr);
CHECK(uarg{r, std::move(n2)}.cast<const int*>(r) == nullptr);
CHECK(uarg{n1}.cast<D*>() == nullptr);
CHECK(uarg{std::move(n1)}.cast<D*>() == nullptr);
CHECK(uarg{n2}.cast<D*>() == nullptr);
CHECK(uarg{std::move(n2)}.cast<D*>() == nullptr);
CHECK(uarg{r, n1}.cast<D*>(r) == nullptr);
CHECK(uarg{r, std::move(n1)}.cast<D*>(r) == nullptr);
CHECK(uarg{r, n2}.cast<D*>(r) == nullptr);
CHECK(uarg{r, std::move(n2)}.cast<D*>(r) == nullptr);
CHECK(uarg{n1}.cast<const D*>() == nullptr);
CHECK(uarg{std::move(n1)}.cast<const D*>() == nullptr);
CHECK(uarg{n2}.cast<const D*>() == nullptr);
CHECK(uarg{std::move(n2)}.cast<const D*>() == nullptr);
CHECK(uarg{r, n1}.cast<const D*>(r) == nullptr);
CHECK(uarg{r, std::move(n1)}.cast<const D*>(r) == nullptr);
CHECK(uarg{r, n2}.cast<const D*>(r) == nullptr);
CHECK(uarg{r, std::move(n2)}.cast<const D*>(r) == nullptr);
}
}

160
develop/untests/meta_utilities/arg_tests.cpp
View File

@@ -74,16 +74,16 @@ namespace
meta::function f_state{function_state::make<meta::function_policy::as_copy_t>("", function_ptr, {})};\
\
if ( std::is_invocable_v<decltype(function_ptr), decltype(FromValue)> ) {\
CHECK(uarg{FromValue}.can_cast_to<ToType>());\
CHECK(uarg_base{type_list<decltype(FromValue)>{}}.can_cast_to<ToType>());\
std::ignore = uarg{FromValue}.cast<ToType>();\
CHECK(uarg{r, FromValue}.can_cast_to<ToType>(r));\
CHECK(uarg_base{r, type_list<decltype(FromValue)>{}}.can_cast_to<ToType>(r));\
std::ignore = uarg{r, FromValue}.cast<ToType>(r);\
\
CHECK(f_state.is_invocable_with<decltype(FromValue)>());\
CHECK(f_state.invoke(FromValue).get_as<int>() == 1);\
} else {\
CHECK_FALSE(uarg{FromValue}.can_cast_to<ToType>());\
CHECK_FALSE(uarg_base{type_list<decltype(FromValue)>{}}.can_cast_to<ToType>());\
/*CHECK_THROWS(std::ignore = uarg{FromValue}.cast<ToType>());*/\
CHECK_FALSE(uarg{r, FromValue}.can_cast_to<ToType>(r));\
CHECK_FALSE(uarg_base{r, type_list<decltype(FromValue)>{}}.can_cast_to<ToType>(r));\
/*CHECK_THROWS(std::ignore = uarg{r, FromValue}.cast<ToType>(r));*/\
\
CHECK_FALSE(f_state.is_invocable_with<decltype(FromValue)>());\
CHECK_FALSE(f_state.safe_invoke(FromValue));\
@@ -118,6 +118,9 @@ TEST_CASE("meta/meta_utilities/arg") {
TEST_CASE("meta/meta_utilities/arg/refs") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
// lvalue
@@ -125,9 +128,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto LV2 = []() -> dclazz& { static dclazz v; return v; };
auto LV3 = []() -> int& { static int v{1}; return v; };
meta::detail::uarg a{LV()};
uarg a{r, LV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE(LV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(LV(), f2, const clazz)
@@ -157,9 +160,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto CLV2 = []() -> const dclazz& { static dclazz v; return v; };
auto CLV3 = []() -> const int& { static int v{1}; return v; };
meta::detail::uarg a{CLV()};
uarg a{r, CLV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE(CLV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(CLV(), f2, const clazz)
@@ -189,9 +192,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto XV2 = []() -> dclazz&& { static dclazz v; return std::move(v); };
auto XV3 = []() -> int&& { static int v{1}; return std::move(v); };
meta::detail::uarg a{XV()};
uarg a{r, XV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(XV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(XV(), f2, const clazz)
@@ -221,9 +224,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto CXV2 = []() -> const dclazz&& { static dclazz v; return std::move(v); };
auto CXV3 = []() -> const int&& { static int v{1}; return std::move(v); };
meta::detail::uarg a{CXV()};
uarg a{r, CXV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE(CXV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(CXV(), f2, const clazz)
@@ -253,9 +256,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto PRV2 = []() -> dclazz { return dclazz{}; };
auto PRV3 = []() -> int { return int{1}; };
meta::detail::uarg a{PRV()};
uarg a{r, PRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(PRV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(PRV(), f2, const clazz)
@@ -284,9 +287,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
auto CPRV = []() -> const clazz { return clazz{}; };
auto CPRV2 = []() -> const dclazz { return dclazz{}; };
meta::detail::uarg a{CPRV()};
uarg a{r, CPRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE(CPRV(), f1, clazz)
META_HPP_CHECK_INVOCABLE(CPRV(), f2, const clazz)
@@ -306,6 +309,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") {
TEST_CASE("meta/meta_utilities/arg/ptrs") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
// lvalue
@@ -314,9 +320,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto LV2_PTR = []() -> dclazz*& { static dclazz v; static dclazz* p{&v}; return p; };
auto LV3_PTR = []() -> int*& { static int v{1}; static int* p{&v}; return p; };
meta::detail::uarg a{LV_PTR()};
uarg a{r, LV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE(LV_PTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(LV_PTR(), f2, clazz* const)
@@ -365,9 +371,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto LV2_CPTR = []() -> const dclazz*& { static dclazz v; static const dclazz* p{&v}; return p; };
auto LV3_CPTR = []() -> const int*& { static int v{1}; static const int* p{&v}; return p; };
meta::detail::uarg a{LV_CPTR()};
uarg a{r, LV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE(LV_CPTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(LV_CPTR(), f2, clazz* const)
@@ -420,9 +426,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto CLV2_PTR = []() -> dclazz* const& { static dclazz v; static dclazz* p{&v}; return p; };
auto CLV3_PTR = []() -> int* const& { static int v{1}; static int* p{&v}; return p; };
meta::detail::uarg a{CLV_PTR()};
uarg a{r, CLV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE(CLV_PTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(CLV_PTR(), f2, clazz* const)
@@ -471,9 +477,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto CLV2_CPTR = []() -> const dclazz* const& { static dclazz v; static const dclazz* p{&v}; return p; };
auto CLV3_CPTR = []() -> const int* const& { static int v{1}; static const int* p{&v}; return p; };
meta::detail::uarg a{CLV_CPTR()};
uarg a{r, CLV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE(CLV_CPTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(CLV_CPTR(), f2, clazz* const)
@@ -526,9 +532,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto XV2_PTR = []() -> dclazz*&& { static dclazz v; static dclazz* p{&v}; return std::move(p); };
auto XV3_PTR = []() -> int*&& { static int v{1}; static int* p{&v}; return std::move(p); };
meta::detail::uarg a{XV_PTR()};
uarg a{r, XV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(XV_PTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(XV_PTR(), f2, clazz* const)
@@ -577,9 +583,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto XV2_CPTR = []() -> const dclazz*&& { static dclazz v; static const dclazz* p{&v}; return std::move(p); };
auto XV3_CPTR = []() -> const int*&& { static int v{1}; static const int* p{&v}; return std::move(p); };
meta::detail::uarg a{XV_CPTR()};
uarg a{r, XV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(XV_CPTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(XV_CPTR(), f2, clazz* const)
@@ -632,9 +638,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto CXV2_PTR = []() -> dclazz* const&& { static dclazz v; static dclazz* p{&v}; return std::move(p); };
auto CXV3_PTR = []() -> int* const&& { static int v{1}; static int* p{&v}; return std::move(p); };
meta::detail::uarg a{CXV_PTR()};
uarg a{r, CXV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE(CXV_PTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(CXV_PTR(), f2, clazz* const)
@@ -683,9 +689,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto CXV2_CPTR = []() -> const dclazz* const&& { static dclazz v; static const dclazz* p{&v}; return std::move(p); };
auto CXV3_CPTR = []() -> const int* const&& { static int v{1}; static const int* p{&v}; return std::move(p); };
meta::detail::uarg a{CXV_CPTR()};
uarg a{r, CXV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE(CXV_CPTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(CXV_CPTR(), f2, clazz* const)
@@ -738,9 +744,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto PRV2_PTR = []() -> dclazz* { static dclazz v; static dclazz* p{&v}; return p; };
auto PRV3_PTR = []() -> int* { static int v{1}; static int* p{&v}; return p; };
meta::detail::uarg a{PRV_PTR()};
uarg a{r, PRV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(PRV_PTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(PRV_PTR(), f2, clazz* const)
@@ -789,9 +795,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
auto PRV2_CPTR = []() -> const dclazz* { static dclazz v; static const dclazz* p{&v}; return p; };
auto PRV3_CPTR = []() -> const int* { static int v{1}; static const int* p{&v}; return p; };
meta::detail::uarg a{PRV_CPTR()};
uarg a{r, PRV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE(PRV_CPTR(), f1, clazz*)
META_HPP_CHECK_INVOCABLE(PRV_CPTR(), f2, clazz* const)
@@ -840,15 +846,18 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") {
TEST_CASE("meta/meta_utilities/arg/values") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
auto LV = []() -> meta::uvalue& { static meta::uvalue v{clazz{}}; return v; };
auto LV2 = []() -> meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; };
auto LV3 = []() -> meta::uvalue& { static meta::uvalue v{int{1}}; return v; };
meta::detail::uarg a{LV()};
uarg a{r, LV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE_2(LV(), f1, clazz&, clazz)
META_HPP_CHECK_INVOCABLE_2(LV(), f2, clazz&, const clazz)
@@ -877,9 +886,9 @@ TEST_CASE("meta/meta_utilities/arg/values") {
auto CLV2 = []() -> const meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; };
auto CLV3 = []() -> const meta::uvalue& { static meta::uvalue v{int{1}}; return v; };
meta::detail::uarg a{CLV()};
uarg a{r, CLV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE_2(CLV(), f1, const clazz&, clazz)
META_HPP_CHECK_INVOCABLE_2(CLV(), f2, const clazz&, const clazz)
@@ -908,9 +917,9 @@ TEST_CASE("meta/meta_utilities/arg/values") {
auto XV2 = []() -> meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); };
auto XV3 = []() -> meta::uvalue&& { static meta::uvalue v{int{1}}; return std::move(v); };
meta::detail::uarg a{XV()};
uarg a{r, XV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(XV(), f1, clazz&&, clazz)
META_HPP_CHECK_INVOCABLE_2(XV(), f2, clazz&&, const clazz)
@@ -939,9 +948,9 @@ TEST_CASE("meta/meta_utilities/arg/values") {
auto CXV2 = []() -> const meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); };
auto CXV3 = []() -> const meta::uvalue&& { static meta::uvalue v{int{1}}; return std::move(v); };
meta::detail::uarg a{CXV()};
uarg a{r, CXV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CXV(), f1, const clazz&&, clazz)
META_HPP_CHECK_INVOCABLE_2(CXV(), f2, const clazz&&, const clazz)
@@ -970,9 +979,9 @@ TEST_CASE("meta/meta_utilities/arg/values") {
auto PRV2 = []() -> meta::uvalue { return meta::uvalue{dclazz{}}; };
auto PRV3 = []() -> meta::uvalue { return meta::uvalue{int{1}}; };
meta::detail::uarg a{PRV()};
uarg a{r, PRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(PRV(), f1, clazz, clazz)
META_HPP_CHECK_INVOCABLE_2(PRV(), f2, clazz, const clazz)
@@ -1001,9 +1010,9 @@ TEST_CASE("meta/meta_utilities/arg/values") {
auto CPRV2 = []() -> const meta::uvalue { return meta::uvalue{dclazz{}}; };
auto CPRV3 = []() -> const meta::uvalue { return meta::uvalue{int{1}}; };
meta::detail::uarg a{CPRV()};
uarg a{r, CPRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CPRV(), f1, const clazz, clazz)
META_HPP_CHECK_INVOCABLE_2(CPRV(), f2, const clazz, const clazz)
@@ -1030,14 +1039,17 @@ TEST_CASE("meta/meta_utilities/arg/values") {
TEST_CASE("meta/meta_utilities/arg/ptr_values") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
auto LV_PTR = []() -> meta::uvalue& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto LV2_PTR = []() -> meta::uvalue& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{LV_PTR()};
uarg a{r, LV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE_2(LV_PTR(), f1, clazz*&, clazz*)
META_HPP_CHECK_INVOCABLE_2(LV_PTR(), f2, clazz*&, clazz* const)
@@ -1072,9 +1084,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto LV_CPTR = []() -> meta::uvalue& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto LV2_CPTR = []() -> meta::uvalue& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{LV_CPTR()};
uarg a{r, LV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE_2(LV_CPTR(), f1, const clazz*&, clazz*)
META_HPP_CHECK_INVOCABLE_2(LV_CPTR(), f2, const clazz*&, clazz* const)
@@ -1109,9 +1121,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CLV_PTR = []() -> const meta::uvalue& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto CLV2_PTR = []() -> const meta::uvalue& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{CLV_PTR()};
uarg a{r, CLV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE_2(CLV_PTR(), f1, clazz* const&, clazz*)
META_HPP_CHECK_INVOCABLE_2(CLV_PTR(), f2, clazz* const&, clazz* const)
@@ -1146,9 +1158,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CLV_CPTR = []() -> const meta::uvalue& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto CLV2_CPTR = []() -> const meta::uvalue& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{CLV_CPTR()};
uarg a{r, CLV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE_2(CLV_CPTR(), f1, const clazz* const&, clazz*)
META_HPP_CHECK_INVOCABLE_2(CLV_CPTR(), f2, const clazz* const&, clazz* const)
@@ -1183,9 +1195,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto XV_PTR = []() -> meta::uvalue&& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
auto XV2_PTR = []() -> meta::uvalue&& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
meta::detail::uarg a{XV_PTR()};
uarg a{r, XV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(XV_PTR(), f1, clazz*&&, clazz*)
META_HPP_CHECK_INVOCABLE_2(XV_PTR(), f2, clazz*&&, clazz* const)
@@ -1220,9 +1232,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto XV_CPTR = []() -> meta::uvalue&& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
auto XV2_CPTR = []() -> meta::uvalue&& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
meta::detail::uarg a{XV_CPTR()};
uarg a{r, XV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(XV_CPTR(), f1, const clazz*&&, clazz*)
META_HPP_CHECK_INVOCABLE_2(XV_CPTR(), f2, const clazz*&&, clazz* const)
@@ -1257,9 +1269,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CXV_PTR = []() -> const meta::uvalue&& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
auto CXV2_PTR = []() -> const meta::uvalue&& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
meta::detail::uarg a{CXV_PTR()};
uarg a{r, CXV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CXV_PTR(), f1, clazz* const&&, clazz*)
META_HPP_CHECK_INVOCABLE_2(CXV_PTR(), f2, clazz* const&&, clazz* const)
@@ -1294,9 +1306,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CXV_CPTR = []() -> const meta::uvalue&& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
auto CXV2_CPTR = []() -> const meta::uvalue&& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); };
meta::detail::uarg a{CXV_CPTR()};
uarg a{r, CXV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CXV_CPTR(), f1, const clazz* const&&, clazz*)
META_HPP_CHECK_INVOCABLE_2(CXV_CPTR(), f2, const clazz* const&&, clazz* const)
@@ -1331,9 +1343,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto PRV_PTR = []() -> meta::uvalue { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto PRV2_PTR = []() -> meta::uvalue { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{PRV_PTR()};
uarg a{r, PRV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(PRV_PTR(), f1, clazz*, clazz*)
META_HPP_CHECK_INVOCABLE_2(PRV_PTR(), f2, clazz*, clazz* const)
@@ -1368,9 +1380,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto PRV_CPTR = []() -> meta::uvalue { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto PRV2_CPTR = []() -> meta::uvalue { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{PRV_CPTR()};
uarg a{r, PRV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(PRV_CPTR(), f1, const clazz*, clazz*)
META_HPP_CHECK_INVOCABLE_2(PRV_CPTR(), f2, const clazz*, clazz* const)
@@ -1405,9 +1417,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CPRV_PTR = []() -> const meta::uvalue { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto CPRV2_PTR = []() -> const meta::uvalue { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{CPRV_PTR()};
uarg a{r, CPRV_PTR()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CPRV_PTR(), f1, clazz* const, clazz*)
META_HPP_CHECK_INVOCABLE_2(CPRV_PTR(), f2, clazz* const, clazz* const)
@@ -1442,9 +1454,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") {
auto CPRV_CPTR = []() -> const meta::uvalue { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; };
auto CPRV2_CPTR = []() -> const meta::uvalue { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; };
meta::detail::uarg a{CPRV_CPTR()};
uarg a{r, CPRV_CPTR()};
CHECK(a.get_raw_type() == meta::resolve_type<const clazz*>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CPRV_CPTR(), f1, const clazz* const, clazz*)
META_HPP_CHECK_INVOCABLE_2(CPRV_CPTR(), f2, const clazz* const, clazz* const)

68
develop/untests/meta_utilities/inst_tests.cpp
View File

@@ -34,16 +34,16 @@ namespace
meta::method m_state{method_state::make<meta::method_policy::as_copy_t>("", method_ptr, {})};\
\
if ( std::is_invocable_v<decltype(method_ptr), decltype(Inst)> ) {\
CHECK(uinst{Inst}.can_cast_to<clazz Qualifiers>());\
CHECK(uinst_base{type_list<decltype(Inst)>{}}.can_cast_to<clazz Qualifiers>());\
std::ignore = uinst{Inst}.cast<clazz Qualifiers>();\
CHECK(uinst{r, Inst}.can_cast_to<clazz Qualifiers>(r));\
CHECK(uinst_base{r, type_list<decltype(Inst)>{}}.can_cast_to<clazz Qualifiers>(r));\
std::ignore = uinst{r, Inst}.cast<clazz Qualifiers>(r);\
\
CHECK(m_state.is_invocable_with<decltype(Inst)>());\
CHECK(m_state.invoke(Inst).get_as<int>() == 1);\
} else {\
CHECK_FALSE(uinst{Inst}.can_cast_to<clazz Qualifiers>());\
CHECK_FALSE(uinst_base{type_list<decltype(Inst)>{}}.can_cast_to<clazz Qualifiers>());\
/*CHECK_THROWS(std::ignore = uinst{Inst}.cast<clazz Qualifiers>());*/\
CHECK_FALSE(uinst{r, Inst}.can_cast_to<clazz Qualifiers>(r));\
CHECK_FALSE(uinst_base{r, type_list<decltype(Inst)>{}}.can_cast_to<clazz Qualifiers>(r));\
/*CHECK_THROWS(std::ignore = uinst{r, Inst}.cast<clazz Qualifiers>(r));*/\
\
CHECK_FALSE(m_state.is_invocable_with<decltype(Inst)>());\
CHECK_FALSE(m_state.safe_invoke(Inst));\
@@ -78,6 +78,10 @@ TEST_CASE("meta/meta_utilities/inst2") {
TEST_CASE("meta/meta_utilities/inst2/refs") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::uinst;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
// lvalue
@@ -85,9 +89,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto LV2 = []() -> dclazz& { static dclazz v; return v; };
{
meta::detail::uinst i{LV()};
uinst i{r, LV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::lvalue);
CHECK(i.get_ref_type() == uinst::ref_types::lvalue);
}
META_HPP_CHECK_INVOCABLE(LV(), m1, )
@@ -111,9 +115,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto CLV2 = []() -> const dclazz& { static dclazz v; return v; };
{
meta::detail::uinst i{CLV()};
uinst i{r, CLV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_lvalue);
CHECK(i.get_ref_type() == uinst::ref_types::const_lvalue);
}
META_HPP_CHECK_INVOCABLE(CLV(), m1, )
@@ -137,9 +141,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto XV2 = []() -> dclazz&& { static dclazz v; return std::move(v); };
{
meta::detail::uinst i{XV()};
uinst i{r, XV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::rvalue);
CHECK(i.get_ref_type() == uinst::ref_types::rvalue);
}
META_HPP_CHECK_INVOCABLE(XV(), m1, )
@@ -163,9 +167,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto CXV2 = []() -> const dclazz&& { static dclazz v; return std::move(v); };
{
meta::detail::uinst i{CXV()};
uinst i{r, CXV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_rvalue);
CHECK(i.get_ref_type() == uinst::ref_types::const_rvalue);
}
META_HPP_CHECK_INVOCABLE(CXV(), m1, )
@@ -189,9 +193,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto PRV2 = []() -> dclazz { return dclazz{}; };
{
meta::detail::uinst i{PRV()};
uinst i{r, PRV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::rvalue);
CHECK(i.get_ref_type() == uinst::ref_types::rvalue);
}
META_HPP_CHECK_INVOCABLE(PRV(), m1, )
@@ -215,9 +219,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
auto CPRV2 = []() -> const dclazz { return dclazz{}; };
{
meta::detail::uinst i{CPRV()};
uinst i{r, CPRV()};
CHECK(i.get_raw_type() == meta::resolve_type<clazz>());
CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_rvalue);
CHECK(i.get_ref_type() == uinst::ref_types::const_rvalue);
}
META_HPP_CHECK_INVOCABLE(CPRV(), m1, )
@@ -238,15 +242,19 @@ TEST_CASE("meta/meta_utilities/inst2/refs") {
TEST_CASE("meta/meta_utilities/inst2/values") {
namespace meta = meta_hpp;
using meta::detail::uarg;
using meta::detail::uinst;
using meta::detail::type_registry;
type_registry& r{type_registry::instance()};
{
// lvalue
auto LV = []() -> meta::uvalue& { static meta::uvalue v{clazz{}}; return v; };
auto LV2 = []() -> meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; };
meta::detail::uarg a{LV()};
uarg a{r, LV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::lvalue);
META_HPP_CHECK_INVOCABLE_2(LV(), m1, clazz&, )
META_HPP_CHECK_INVOCABLE_2(LV(), m2, clazz&, &)
@@ -268,9 +276,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") {
auto CLV = []() -> const meta::uvalue& { static meta::uvalue v{clazz{}}; return v; };
auto CLV2 = []() -> const meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; };
meta::detail::uarg a{CLV()};
uarg a{r, CLV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue);
META_HPP_CHECK_INVOCABLE_2(CLV(), m1, const clazz&, )
META_HPP_CHECK_INVOCABLE_2(CLV(), m2, const clazz&, &)
@@ -292,9 +300,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") {
auto XV = []() -> meta::uvalue&& { static meta::uvalue v{clazz{}}; return std::move(v); };
auto XV2 = []() -> meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); };
meta::detail::uarg a{XV()};
uarg a{r, XV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(XV(), m1, clazz&&, )
META_HPP_CHECK_INVOCABLE_2(XV(), m2, clazz&&, &)
@@ -316,9 +324,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") {
auto CXV = []() -> const meta::uvalue&& { static meta::uvalue v{clazz{}}; return std::move(v); };
auto CXV2 = []() -> const meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); };
meta::detail::uarg a{CXV()};
uarg a{r, CXV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CXV(), m1, const clazz&&, )
META_HPP_CHECK_INVOCABLE_2(CXV(), m2, const clazz&&, &)
@@ -340,9 +348,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") {
auto PRV = []() -> meta::uvalue { return meta::uvalue{clazz{}}; };
auto PRV2 = []() -> meta::uvalue { return meta::uvalue{dclazz{}}; };
meta::detail::uarg a{PRV()};
uarg a{r, PRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::rvalue);
META_HPP_CHECK_INVOCABLE_2(PRV(), m1, clazz, )
META_HPP_CHECK_INVOCABLE_2(PRV(), m2, clazz, &)
@@ -364,9 +372,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") {
auto CPRV = []() -> const meta::uvalue { return meta::uvalue{clazz{}}; };
auto CPRV2 = []() -> const meta::uvalue { return meta::uvalue{dclazz{}}; };
meta::detail::uarg a{CPRV()};
uarg a{r, CPRV()};
CHECK(a.get_raw_type() == meta::resolve_type<clazz>());
CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue);
CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue);
META_HPP_CHECK_INVOCABLE_2(CPRV(), m1, const clazz, )
META_HPP_CHECK_INVOCABLE_2(CPRV(), m2, const clazz, &)

2
headers/meta.hpp/meta_base/fixed_function.hpp
View File

@@ -85,7 +85,7 @@ namespace meta_hpp::detail
private:
struct buffer_t final {
// NOLINTNEXTLINE(*-avoid-c-arrays)
alignas(std::max_align_t) std::byte data[sizeof(void*) * 2];
alignas(std::max_align_t) std::byte data[sizeof(void*) * 3];
} buffer_{};
};

84
headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
View File

@@ -39,32 +39,32 @@ namespace meta_hpp::detail
template < typename T, typename Tp = std::decay_t<T> >
requires(!any_uvalue_kind<Tp>)
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uarg_base(T&&)
: uarg_base{type_list<T&&>{}} {}
explicit uarg_base(type_registry& registry, T&&)
: uarg_base{registry, type_list<T&&>{}} {}
template < arg_lvalue_ref_kind T >
explicit uarg_base(type_list<T>)
explicit uarg_base(type_registry& registry, type_list<T>)
: ref_type_{std::is_const_v<std::remove_reference_t<T>> ? ref_types::const_lvalue : ref_types::lvalue}
, raw_type_{resolve_type<std::remove_cvref_t<T>>()} {}
, raw_type_{registry.resolve_type<std::remove_cvref_t<T>>()} {}
template < arg_rvalue_ref_kind T >
explicit uarg_base(type_list<T>)
explicit uarg_base(type_registry& registry, type_list<T>)
: ref_type_{std::is_const_v<std::remove_reference_t<T>> ? ref_types::const_rvalue : ref_types::rvalue}
, raw_type_{resolve_type<std::remove_cvref_t<T>>()} {}
, raw_type_{registry.resolve_type<std::remove_cvref_t<T>>()} {}
explicit uarg_base(uvalue& v)
explicit uarg_base(type_registry&, uvalue& v)
: ref_type_{ref_types::lvalue}
, raw_type_{v.get_type()} {}
explicit uarg_base(const uvalue& v)
explicit uarg_base(type_registry&, const uvalue& v)
: ref_type_{ref_types::const_lvalue}
, raw_type_{v.get_type()} {}
explicit uarg_base(uvalue&& v)
explicit uarg_base(type_registry&, uvalue&& v)
: ref_type_{ref_types::rvalue}
, raw_type_{v.get_type()} {}
explicit uarg_base(const uvalue&& v)
explicit uarg_base(type_registry&, const uvalue&& v)
: ref_type_{ref_types::const_rvalue}
, raw_type_{v.get_type()} {}
@@ -83,11 +83,11 @@ namespace meta_hpp::detail
template < typename To >
requires(std::is_pointer_v<To>)
[[nodiscard]] bool can_cast_to() const noexcept;
[[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept;
template < typename To >
requires(!std::is_pointer_v<To>)
[[nodiscard]] bool can_cast_to() const noexcept;
[[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept;
private:
ref_types ref_type_{};
@@ -110,24 +110,24 @@ namespace meta_hpp::detail
template < typename T, uvalue_kind Tp = std::decay_t<T> >
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uarg(T&& v)
: uarg_base{std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
, data_{const_cast<void*>(v.get_data())} {}
explicit uarg(type_registry& registry, T&& v)
: uarg_base{registry, std::forward<T>(v)}
, data_{const_cast<void*>(v.get_data())} {} // NOLINT(*-const-cast)
template < typename T, typename Tp = std::decay_t<T> >
requires(!any_uvalue_kind<Tp>)
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uarg(T&& v)
: uarg_base{std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
, data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {}
explicit uarg(type_registry& registry, T&& v)
: uarg_base{registry, std::forward<T>(v)}
, data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {} // NOLINT(*-const-cast)
template < typename To >
requires(std::is_pointer_v<To>)
[[nodiscard]] To cast() const;
[[nodiscard]] To cast(type_registry& registry) const;
template < typename To >
requires(!std::is_pointer_v<To>)
[[nodiscard]] To cast() const;
[[nodiscard]] To cast(type_registry& registry) const;
private:
void* data_{};
@@ -138,12 +138,12 @@ namespace meta_hpp::detail
{
template < typename To >
requires(std::is_pointer_v<To>)
[[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
[[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept {
using to_raw_type_cv = std::remove_reference_t<To>;
using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<to_raw_type>();
const any_type& to_type = registry.resolve_type<to_raw_type>();
const auto is_a = [](const any_type& base, const any_type& derived) {
return (base == derived) //
@@ -193,7 +193,7 @@ namespace meta_hpp::detail
template < typename To >
requires(!std::is_pointer_v<To>)
[[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
[[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept {
using to_raw_type_cv = std::remove_reference_t<To>;
using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
@@ -203,7 +203,7 @@ namespace meta_hpp::detail
);
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<to_raw_type>();
const any_type& to_type = registry.resolve_type<to_raw_type>();
const auto is_a = [](const any_type& base, const any_type& derived) {
return (base == derived) //
@@ -258,14 +258,14 @@ namespace meta_hpp::detail
{
template < typename To >
requires(std::is_pointer_v<To>)
[[nodiscard]] To uarg::cast() const {
META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
[[nodiscard]] To uarg::cast(type_registry& registry) const {
META_HPP_ASSERT(can_cast_to<To>(registry) && "bad argument cast");
using to_raw_type_cv = std::remove_reference_t<To>;
using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<to_raw_type>();
const any_type& to_type = registry.resolve_type<to_raw_type>();
if ( to_type.is_pointer() && from_type.is_nullptr() ) {
return static_cast<to_raw_type_cv>(nullptr);
@@ -286,7 +286,7 @@ namespace meta_hpp::detail
const class_type& to_data_class = to_data_type.as_class();
const class_type& from_data_class = from_data_type.as_class();
void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class);
void* to_ptr = pointer_upcast(registry, data_, from_data_class, to_data_class);
return static_cast<to_raw_type_cv>(to_ptr);
}
}
@@ -308,7 +308,7 @@ namespace meta_hpp::detail
const class_type& to_data_class = to_data_type.as_class();
const class_type& from_data_class = from_data_type.as_class();
void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class);
return static_cast<to_raw_type_cv>(to_ptr);
}
}
@@ -318,8 +318,8 @@ namespace meta_hpp::detail
template < typename To >
requires(!std::is_pointer_v<To>)
[[nodiscard]] To uarg::cast() const {
META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
[[nodiscard]] To uarg::cast(type_registry& registry) const {
META_HPP_ASSERT(can_cast_to<To>(registry) && "bad argument cast");
using to_raw_type_cv = std::remove_reference_t<To>;
using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
@@ -330,11 +330,11 @@ namespace meta_hpp::detail
);
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<to_raw_type>();
const any_type& to_type = registry.resolve_type<to_raw_type>();
void* to_ptr = to_type == from_type //
? data_
: pointer_upcast(data_, from_type.as_class(), to_type.as_class());
: pointer_upcast(registry, data_, from_type.as_class(), to_type.as_class());
if constexpr ( std::is_lvalue_reference_v<To> ) {
return *static_cast<to_raw_type_cv*>(to_ptr);
@@ -376,28 +376,28 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < typename ArgTypeList, typename F >
auto call_with_uargs(std::span<const uarg> args, F&& f) {
auto call_with_uargs(type_registry& registry, std::span<const uarg> args, F&& f) {
META_HPP_ASSERT(args.size() == type_list_arity_v<ArgTypeList>);
return [ args, &f ]<std::size_t... Is>(std::index_sequence<Is...>) {
return f(args[Is].cast<type_list_at_t<Is, ArgTypeList>>()...);
return [ args, &registry, &f ]<std::size_t... Is>(std::index_sequence<Is...>) {
return f(args[Is].cast<type_list_at_t<Is, ArgTypeList>>(registry)...);
}
(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
}
template < typename ArgTypeList >
bool can_cast_all_uargs(std::span<const uarg> args) {
bool can_cast_all_uargs(type_registry& registry, std::span<const uarg> args) {
META_HPP_ASSERT(args.size() == type_list_arity_v<ArgTypeList>);
return [args]<std::size_t... Is>(std::index_sequence<Is...>) {
return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>());
return [ args, &registry ]<std::size_t... Is>(std::index_sequence<Is...>) {
return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
}
(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
}
template < typename ArgTypeList >
bool can_cast_all_uargs(std::span<const uarg_base> args) {
bool can_cast_all_uargs(type_registry& registry, std::span<const uarg_base> args) {
META_HPP_ASSERT(args.size() == type_list_arity_v<ArgTypeList>);
return [args]<std::size_t... Is>(std::index_sequence<Is...>) {
return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>());
return [ args, &registry ]<std::size_t... Is>(std::index_sequence<Is...>) {
return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
}
(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
}

46
headers/meta.hpp/meta_detail/value_utilities/uinst.hpp
View File

@@ -39,32 +39,32 @@ namespace meta_hpp::detail
template < typename T, typename Tp = std::decay_t<T> >
requires(!any_uvalue_kind<Tp>)
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uinst_base(T&&)
: uinst_base{type_list<T&&>{}} {}
explicit uinst_base(type_registry& registry, T&&)
: uinst_base{registry, type_list<T&&>{}} {}
template < inst_class_lvalue_ref_kind T >
explicit uinst_base(type_list<T>)
explicit uinst_base(type_registry& registry, type_list<T>)
: ref_type_{std::is_const_v<std::remove_reference_t<T>> ? ref_types::const_lvalue : ref_types::lvalue}
, raw_type_{resolve_type<std::remove_cvref_t<T>>()} {}
, raw_type_{registry.resolve_type<std::remove_cvref_t<T>>()} {}
template < inst_class_rvalue_ref_kind T >
explicit uinst_base(type_list<T>)
explicit uinst_base(type_registry& registry, type_list<T>)
: ref_type_{std::is_const_v<std::remove_reference_t<T>> ? ref_types::const_rvalue : ref_types::rvalue}
, raw_type_{resolve_type<std::remove_cvref_t<T>>()} {}
, raw_type_{registry.resolve_type<std::remove_cvref_t<T>>()} {}
explicit uinst_base(uvalue& v)
explicit uinst_base(type_registry&, uvalue& v)
: ref_type_{ref_types::lvalue}
, raw_type_{v.get_type()} {}
explicit uinst_base(const uvalue& v)
explicit uinst_base(type_registry&, const uvalue& v)
: ref_type_{ref_types::const_lvalue}
, raw_type_{v.get_type()} {}
explicit uinst_base(uvalue&& v)
explicit uinst_base(type_registry&, uvalue&& v)
: ref_type_{ref_types::rvalue}
, raw_type_{v.get_type()} {}
explicit uinst_base(const uvalue&& v)
explicit uinst_base(type_registry&, const uvalue&& v)
: ref_type_{ref_types::const_rvalue}
, raw_type_{v.get_type()} {}
@@ -87,7 +87,7 @@ namespace meta_hpp::detail
}
template < inst_class_ref_kind Q >
[[nodiscard]] bool can_cast_to() const noexcept;
[[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept;
private:
ref_types ref_type_{};
@@ -110,19 +110,19 @@ namespace meta_hpp::detail
template < typename T, uvalue_kind Tp = std::decay_t<T> >
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uinst(T&& v)
: uinst_base{std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
explicit uinst(type_registry& registry, T&& v)
: uinst_base{registry, std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
, data_{const_cast<void*>(v.get_data())} {}
template < typename T, typename Tp = std::decay_t<T> >
requires(!any_uvalue_kind<Tp>)
// NOLINTNEXTLINE(*-forwarding-reference-overload)
explicit uinst(T&& v)
: uinst_base{std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
explicit uinst(type_registry& registry, T&& v)
: uinst_base{registry, std::forward<T>(v)} // NOLINTNEXTLINE(*-const-cast)
, data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {}
template < inst_class_ref_kind Q >
[[nodiscard]] decltype(auto) cast() const;
[[nodiscard]] decltype(auto) cast(type_registry& registry) const;
private:
void* data_{};
@@ -132,12 +132,12 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < inst_class_ref_kind Q >
bool uinst_base::can_cast_to() const noexcept {
bool uinst_base::can_cast_to(type_registry& registry) const noexcept {
using inst_class = typename inst_traits<Q>::class_type;
using inst_method = typename inst_traits<Q>::method_type;
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<inst_class>();
const any_type& to_type = registry.resolve_type<inst_class>();
const auto is_a = [](const any_type& base, const any_type& derived) {
return (base == derived) //
@@ -182,20 +182,20 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < inst_class_ref_kind Q >
decltype(auto) uinst::cast() const {
META_HPP_ASSERT(can_cast_to<Q>() && "bad instance cast");
decltype(auto) uinst::cast(type_registry& registry) const {
META_HPP_ASSERT(can_cast_to<Q>(registry) && "bad instance cast");
using inst_class_cv = std::remove_reference_t<Q>;
using inst_class = std::remove_cv_t<inst_class_cv>;
const any_type& from_type = get_raw_type();
const any_type& to_type = resolve_type<inst_class>();
const any_type& to_type = registry.resolve_type<inst_class>();
if ( from_type.is_class() && to_type.is_class() ) {
const class_type& from_class = from_type.as_class();
const class_type& to_class = to_type.as_class();
void* to_ptr = pointer_upcast(data_, from_class, to_class);
void* to_ptr = pointer_upcast(registry, data_, from_class, to_class);
if constexpr ( !std::is_reference_v<Q> ) {
return *static_cast<inst_class_cv*>(to_ptr);
@@ -219,7 +219,7 @@ namespace meta_hpp::detail
const class_type& to_class = to_type.as_class();
void** from_data_ptr = static_cast<void**>(data_);
void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_class);
void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_class);
if constexpr ( !std::is_reference_v<Q> ) {
return *static_cast<inst_class_cv*>(to_ptr);

26
headers/meta.hpp/meta_detail/value_utilities/utraits.hpp
View File

@@ -98,7 +98,12 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
[[nodiscard]] inline void* pointer_upcast(void* ptr, const class_type& from, const class_type& to) {
[[nodiscard]] inline void* pointer_upcast( //
type_registry& registry,
void* ptr,
const class_type& from,
const class_type& to
) {
if ( nullptr == ptr || !from || !to ) {
return nullptr;
}
@@ -113,25 +118,30 @@ namespace meta_hpp::detail
}
if ( base_type.is_derived_from(to) ) {
return pointer_upcast(base_info.upcast(ptr), base_type, to);
return pointer_upcast(registry, base_info.upcast(ptr), base_type, to);
}
}
return nullptr;
}
[[nodiscard]] inline const void* pointer_upcast(const void* ptr, const class_type& from, const class_type& to) {
[[nodiscard]] inline const void* pointer_upcast( //
type_registry& registry,
const void* ptr,
const class_type& from,
const class_type& to
) {
// NOLINTNEXTLINE(*-const-cast)
return pointer_upcast(const_cast<void*>(ptr), from, to);
return pointer_upcast(registry, const_cast<void*>(ptr), from, to);
}
template < class_kind To, class_kind From >
[[nodiscard]] To* pointer_upcast(From* ptr) {
return static_cast<To*>(pointer_upcast(ptr, resolve_type<From>(), resolve_type<To>()));
[[nodiscard]] To* pointer_upcast(type_registry& registry, From* ptr) {
return static_cast<To*>(pointer_upcast(registry, ptr, registry.resolve_type<From>(), registry.resolve_type<To>()));
}
template < class_kind To, class_kind From >
[[nodiscard]] const To* pointer_upcast(const From* ptr) {
return static_cast<const To*>(pointer_upcast(ptr, resolve_type<From>(), resolve_type<To>()));
[[nodiscard]] const To* pointer_upcast(type_registry& registry, const From* ptr) {
return static_cast<const To*>(pointer_upcast(registry, ptr, registry.resolve_type<From>(), registry.resolve_type<To>()));
}
}

51
headers/meta.hpp/meta_invoke/invoke.hpp
View File

@@ -27,8 +27,9 @@ namespace meta_hpp
template < detail::function_pointer_kind Function, typename... Args >
uvalue invoke(Function function_ptr, Args&&... args) {
using namespace detail;
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
return raw_function_invoke<function_policy::as_copy_t>(function_ptr, vargs);
type_registry& registry{type_registry::instance()};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return raw_function_invoke<function_policy::as_copy_t>(registry, function_ptr, vargs);
}
}
@@ -42,8 +43,9 @@ namespace meta_hpp
template < detail::member_pointer_kind Member, typename Instance >
uvalue invoke(Member member_ptr, Instance&& instance) {
using namespace detail;
const uinst vinst{std::forward<Instance>(instance)};
return raw_member_getter<member_policy::as_copy_t>(member_ptr, vinst);
type_registry& registry{type_registry::instance()};
const uinst vinst{registry, std::forward<Instance>(instance)};
return raw_member_getter<member_policy::as_copy_t>(registry, member_ptr, vinst);
}
}
@@ -57,9 +59,10 @@ namespace meta_hpp
template < detail::method_pointer_kind Method, typename Instance, typename... Args >
uvalue invoke(Method method_ptr, Instance&& instance, Args&&... args) {
using namespace detail;
const uinst vinst{std::forward<Instance>(instance)};
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
return raw_method_invoke<method_policy::as_copy_t>(method_ptr, vinst, vargs);
type_registry& registry{type_registry::instance()};
const uinst vinst{registry, std::forward<Instance>(instance)};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return raw_method_invoke<method_policy::as_copy_t>(registry, method_ptr, vinst, vargs);
}
}
@@ -78,15 +81,17 @@ namespace meta_hpp
template < detail::function_pointer_kind Function, typename... Args >
bool is_invocable_with() {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
return raw_function_is_invocable_with<Function>(vargs);
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, type_list<Args>{}}...};
return raw_function_is_invocable_with<Function>(registry, vargs);
}
template < detail::function_pointer_kind Function, typename... Args >
bool is_invocable_with(Args&&... args) {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
return raw_function_is_invocable_with<Function>(vargs);
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, std::forward<Args>(args)}...};
return raw_function_is_invocable_with<Function>(registry, vargs);
}
}
@@ -105,15 +110,17 @@ namespace meta_hpp
template < detail::member_pointer_kind Member, typename Instance >
bool is_invocable_with() {
using namespace detail;
const uinst_base vinst{type_list<Instance>{}};
return raw_member_is_gettable_with<Member>(vinst);
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, type_list<Instance>{}};
return raw_member_is_gettable_with<Member>(registry, vinst);
}
template < detail::member_pointer_kind Member, typename Instance >
bool is_invocable_with(Instance&& instance) {
using namespace detail;
const uinst_base vinst{std::forward<Instance>(instance)};
return raw_member_is_gettable_with<Member>(vinst);
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, std::forward<Instance>(instance)};
return raw_member_is_gettable_with<Member>(registry, vinst);
}
}
@@ -132,16 +139,18 @@ namespace meta_hpp
template < detail::method_pointer_kind Method, typename Instance, typename... Args >
bool is_invocable_with() {
using namespace detail;
const uinst_base vinst{type_list<Instance>{}};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
return raw_method_is_invocable_with<Method>(vinst, vargs);
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, type_list<Instance>{}};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, type_list<Args>{}}...};
return raw_method_is_invocable_with<Method>(registry, vinst, vargs);
}
template < detail::method_pointer_kind Method, typename Instance, typename... Args >
bool is_invocable_with(Instance&& instance, Args&&... args) {
using namespace detail;
const uinst_base vinst{std::forward<Instance>(instance)};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
return raw_method_is_invocable_with<Method>(vinst, vargs);
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, std::forward<Instance>(instance)};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, std::forward<Args>(args)}...};
return raw_method_is_invocable_with<Method>(registry, vinst, vargs);
}
}

8
headers/meta.hpp/meta_registry.hpp
View File

@@ -38,12 +38,16 @@ namespace meta_hpp
template < typename... Ts >
[[nodiscard]] any_type_list resolve_types() {
return {resolve_type<Ts>()...};
using namespace detail;
type_registry& registry = type_registry::instance();
return {registry.resolve_type<std::remove_cv_t<Ts>>()...};
}
template < typename... Ts >
[[nodiscard]] any_type_list resolve_types(type_list<Ts...>) {
return {resolve_type<Ts>()...};
using namespace detail;
type_registry& registry = type_registry::instance();
return {registry.resolve_type<std::remove_cv_t<Ts>>()...};
}
}

5
headers/meta.hpp/meta_states/argument.hpp
View File

@@ -9,6 +9,8 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
namespace meta_hpp::detail
{
inline argument_state::argument_state(argument_index nindex, metadata_map nmetadata)
@@ -17,7 +19,8 @@ namespace meta_hpp::detail
template < typename Argument >
inline argument_state_ptr argument_state::make(std::size_t position, metadata_map metadata) {
argument_state state{argument_index{resolve_type<Argument>(), position}, std::move(metadata)};
type_registry& registry{type_registry::instance()};
argument_state state{argument_index{registry.resolve_type<Argument>(), position}, std::move(metadata)};
return make_intrusive<argument_state>(std::move(state));
}
}

56
headers/meta.hpp/meta_states/constructor.hpp
View File

@@ -9,13 +9,14 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_types/constructor_type.hpp"
namespace meta_hpp::detail
{
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
uvalue raw_constructor_create(std::span<const uarg> args) {
uvalue raw_constructor_create(type_registry& registry, std::span<const uarg> args) {
using ct = constructor_traits<Class, Args...>;
using class_type = typename ct::class_type;
using argument_types = typename ct::argument_types;
@@ -38,11 +39,11 @@ namespace meta_hpp::detail
);
META_HPP_ASSERT( //
can_cast_all_uargs<argument_types>(args) //
can_cast_all_uargs<argument_types>(registry, args) //
&& "an attempt to call a constructor with incorrect argument types"
);
return call_with_uargs<argument_types>(args, [](auto&&... all_args) -> uvalue {
return call_with_uargs<argument_types>(registry, args, [](auto&&... all_args) -> uvalue {
if constexpr ( as_object ) {
return make_uvalue<class_type>(META_HPP_FWD(all_args)...);
}
@@ -58,7 +59,7 @@ namespace meta_hpp::detail
}
template < class_kind Class, typename... Args >
uvalue raw_constructor_create_at(void* mem, std::span<const uarg> args) {
uvalue raw_constructor_create_at(type_registry& registry, void* mem, std::span<const uarg> args) {
using ct = constructor_traits<Class, Args...>;
using class_type = typename ct::class_type;
using argument_types = typename ct::argument_types;
@@ -69,40 +70,46 @@ namespace meta_hpp::detail
);
META_HPP_ASSERT( //
can_cast_all_uargs<argument_types>(args) //
can_cast_all_uargs<argument_types>(registry, args) //
&& "an attempt to call a constructor with incorrect argument types"
);
return call_with_uargs<argument_types>(args, [mem](auto&&... all_args) {
return call_with_uargs<argument_types>(registry, args, [mem](auto&&... all_args) {
return std::construct_at(static_cast<class_type*>(mem), META_HPP_FWD(all_args)...);
});
}
template < class_kind Class, typename... Args >
bool raw_constructor_is_invocable_with(std::span<const uarg_base> args) {
bool raw_constructor_is_invocable_with(type_registry& registry, std::span<const uarg_base> args) {
using ct = constructor_traits<Class, Args...>;
using argument_types = typename ct::argument_types;
return args.size() == ct::arity //
&& can_cast_all_uargs<argument_types>(args);
&& can_cast_all_uargs<argument_types>(registry, args);
}
}
namespace meta_hpp::detail
{
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
constructor_state::create_impl make_constructor_create() {
return &raw_constructor_create<Policy, Class, Args...>;
constructor_state::create_impl make_constructor_create(type_registry& registry) {
return [&registry](std::span<const uarg> args) { //
return raw_constructor_create<Policy, Class, Args...>(registry, args);
};
}
template < class_kind Class, typename... Args >
constructor_state::create_at_impl make_constructor_create_at() {
return &raw_constructor_create_at<Class, Args...>;
constructor_state::create_at_impl make_constructor_create_at(type_registry& registry) {
return [&registry](void* mem, std::span<const uarg> args) { //
return raw_constructor_create_at<Class, Args...>(registry, mem, args);
};
}
template < class_kind Class, typename... Args >
constructor_state::is_invocable_with_impl make_constructor_is_invocable_with() {
return &raw_constructor_is_invocable_with<Class, Args...>;
constructor_state::is_invocable_with_impl make_constructor_is_invocable_with(type_registry& registry) {
return [&registry](std::span<const uarg_base> args) { //
return raw_constructor_is_invocable_with<Class, Args...>(registry, args);
};
}
template < class_kind Class, typename... Args >
@@ -129,10 +136,11 @@ namespace meta_hpp::detail
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
constructor_state_ptr constructor_state::make(metadata_map metadata) {
constructor_state state{constructor_index{resolve_constructor_type<Class, Args...>()}, std::move(metadata)};
state.create = make_constructor_create<Policy, Class, Args...>();
state.create_at = make_constructor_create_at<Class, Args...>();
state.is_invocable_with = make_constructor_is_invocable_with<Class, Args...>();
type_registry& registry{type_registry::instance()};
constructor_state state{constructor_index{registry.resolve_constructor_type<Class, Args...>()}, std::move(metadata)};
state.create = make_constructor_create<Policy, Class, Args...>(registry);
state.create_at = make_constructor_create_at<Class, Args...>(registry);
state.is_invocable_with = make_constructor_is_invocable_with<Class, Args...>(registry);
state.arguments = make_constructor_arguments<Class, Args...>();
return make_intrusive<constructor_state>(std::move(state));
}
@@ -147,7 +155,8 @@ namespace meta_hpp
template < typename... Args >
uvalue constructor::create(Args&&... args) const {
using namespace detail;
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return state_->create(vargs);
}
@@ -162,7 +171,8 @@ namespace meta_hpp
template < typename... Args >
uvalue constructor::create_at(void* mem, Args&&... args) const {
using namespace detail;
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return state_->create_at(mem, vargs);
}
@@ -177,14 +187,16 @@ namespace meta_hpp
template < typename... Args >
bool constructor::is_invocable_with() const noexcept {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, type_list<Args>{}}...};
return state_->is_invocable_with(vargs);
}
template < typename... Args >
bool constructor::is_invocable_with(Args&&... args) const noexcept {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, std::forward<Args>(args)}...};
return state_->is_invocable_with(vargs);
}

21
headers/meta.hpp/meta_states/destructor.hpp
View File

@@ -9,21 +9,22 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_types/destructor_type.hpp"
namespace meta_hpp::detail
{
template < class_kind Class >
bool raw_destructor_destroy(const uarg& arg) {
bool raw_destructor_destroy(type_registry& registry, const uarg& arg) {
using dt = destructor_traits<Class>;
using class_type = typename dt::class_type;
if ( !arg.can_cast_to<class_type*>() ) {
if ( !arg.can_cast_to<class_type*>(registry) ) {
return false;
}
std::unique_ptr<class_type>{arg.cast<class_type*>()}.reset();
std::unique_ptr<class_type>{arg.cast<class_type*>(registry)}.reset();
return true;
}
@@ -39,8 +40,10 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < class_kind Class >
destructor_state::destroy_impl make_destructor_destroy() {
return &raw_destructor_destroy<Class>;
destructor_state::destroy_impl make_destructor_destroy(type_registry& registry) {
return [&registry](const uarg& arg) { //
return raw_destructor_destroy<Class>(registry, arg);
};
}
template < class_kind Class >
@@ -57,8 +60,9 @@ namespace meta_hpp::detail
template < class_kind Class >
destructor_state_ptr destructor_state::make(metadata_map metadata) {
destructor_state state{destructor_index{resolve_destructor_type<Class>()}, std::move(metadata)};
state.destroy = make_destructor_destroy<Class>();
type_registry& registry{type_registry::instance()};
destructor_state state{destructor_index{registry.resolve_destructor_type<Class>()}, std::move(metadata)};
state.destroy = make_destructor_destroy<Class>(registry);
state.destroy_at = make_destructor_destroy_at<Class>();
return make_intrusive<destructor_state>(std::move(state));
}
@@ -73,7 +77,8 @@ namespace meta_hpp
template < typename Arg >
bool destructor::destroy(Arg&& arg) const {
using namespace detail;
const uarg varg{std::forward<Arg>(arg)};
type_registry& registry{type_registry::instance()};
const uarg varg{registry, std::forward<Arg>(arg)};
return state_->destroy(varg);
}

4
headers/meta.hpp/meta_states/evalue.hpp
View File

@@ -9,6 +9,7 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_types/enum_type.hpp"
namespace meta_hpp::detail
@@ -19,7 +20,8 @@ namespace meta_hpp::detail
template < enum_kind Enum >
evalue_state_ptr evalue_state::make(std::string name, Enum evalue, metadata_map metadata) {
evalue_state state{evalue_index{resolve_type<Enum>(), std::move(name)}, std::move(metadata)};
type_registry& registry{type_registry::instance()};
evalue_state state{evalue_index{registry.resolve_type<Enum>(), std::move(name)}, std::move(metadata)};
state.enum_value = uvalue{evalue};
state.underlying_value = uvalue{to_underlying(evalue)};
return make_intrusive<evalue_state>(std::move(state));

39
headers/meta.hpp/meta_states/function.hpp
View File

@@ -9,13 +9,14 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_types/function_type.hpp"
namespace meta_hpp::detail
{
template < function_policy_kind Policy, function_pointer_kind Function >
uvalue raw_function_invoke(Function function_ptr, std::span<const uarg> args) {
uvalue raw_function_invoke(type_registry& registry, Function function_ptr, std::span<const uarg> args) {
using ft = function_traits<Function>;
using return_type = typename ft::return_type;
using argument_types = typename ft::argument_types;
@@ -40,11 +41,11 @@ namespace meta_hpp::detail
);
META_HPP_ASSERT( //
can_cast_all_uargs<argument_types>(args) //
can_cast_all_uargs<argument_types>(registry, args) //
&& "an attempt to call a function with incorrect argument types"
);
return call_with_uargs<argument_types>(args, [function_ptr](auto&&... all_args) {
return call_with_uargs<argument_types>(registry, args, [function_ptr](auto&&... all_args) {
if constexpr ( std::is_void_v<return_type> ) {
function_ptr(META_HPP_FWD(all_args)...);
return uvalue{};
@@ -63,27 +64,29 @@ namespace meta_hpp::detail
}
template < function_pointer_kind Function >
bool raw_function_is_invocable_with(std::span<const uarg_base> args) {
bool raw_function_is_invocable_with(type_registry& registry, std::span<const uarg_base> args) {
using ft = function_traits<Function>;
using argument_types = typename ft::argument_types;
return args.size() == ft::arity //
&& can_cast_all_uargs<argument_types>(args);
&& can_cast_all_uargs<argument_types>(registry, args);
}
}
namespace meta_hpp::detail
{
template < function_policy_kind Policy, function_pointer_kind Function >
function_state::invoke_impl make_function_invoke(Function function_ptr) {
return [function_ptr](std::span<const uarg> args) { //
return raw_function_invoke<Policy>(function_ptr, args);
function_state::invoke_impl make_function_invoke(type_registry& registry, Function function_ptr) {
return [&registry, function_ptr](std::span<const uarg> args) { //
return raw_function_invoke<Policy>(registry, function_ptr, args);
};
}
template < function_pointer_kind Function >
function_state::is_invocable_with_impl make_function_is_invocable_with() {
return &raw_function_is_invocable_with<Function>;
function_state::is_invocable_with_impl make_function_is_invocable_with(type_registry& registry) {
return [&registry](std::span<const uarg_base> args) { //
return raw_function_is_invocable_with<Function>(registry, args);
};
}
template < function_pointer_kind Function >
@@ -110,9 +113,10 @@ namespace meta_hpp::detail
template < function_policy_kind Policy, function_pointer_kind Function >
function_state_ptr function_state::make(std::string name, Function function_ptr, metadata_map metadata) {
function_state state{function_index{resolve_type<Function>(), std::move(name)}, std::move(metadata)};
state.invoke = make_function_invoke<Policy>(function_ptr);
state.is_invocable_with = make_function_is_invocable_with<Function>();
type_registry& registry{type_registry::instance()};
function_state state{function_index{registry.resolve_type<Function>(), std::move(name)}, std::move(metadata)};
state.invoke = make_function_invoke<Policy>(registry, function_ptr);
state.is_invocable_with = make_function_is_invocable_with<Function>(registry);
state.arguments = make_function_arguments<Function>();
return make_intrusive<function_state>(std::move(state));
}
@@ -131,7 +135,8 @@ namespace meta_hpp
template < typename... Args >
uvalue function::invoke(Args&&... args) const {
using namespace detail;
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return state_->invoke(vargs);
}
@@ -151,14 +156,16 @@ namespace meta_hpp
template < typename... Args >
bool function::is_invocable_with() const noexcept {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, type_list<Args>{}}...};
return state_->is_invocable_with(vargs);
}
template < typename... Args >
bool function::is_invocable_with(Args&&... args) const noexcept {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, std::forward<Args>(args)}...};
return state_->is_invocable_with(vargs);
}

101
headers/meta.hpp/meta_states/member.hpp
View File

@@ -9,6 +9,7 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_detail/value_utilities/uinst.hpp"
#include "../meta_types/member_type.hpp"
@@ -16,7 +17,7 @@
namespace meta_hpp::detail
{
template < member_policy_kind Policy, member_pointer_kind Member >
uvalue raw_member_getter(Member member_ptr, const uinst& inst) {
uvalue raw_member_getter(type_registry& registry, Member member_ptr, const uinst& inst) {
using mt = member_traits<Member>;
using class_type = typename mt::class_type;
using value_type = typename mt::value_type;
@@ -35,11 +36,11 @@ namespace meta_hpp::detail
if ( inst.is_inst_const() ) {
META_HPP_ASSERT( //
inst.can_cast_to<const class_type>() //
inst.can_cast_to<const class_type>(registry) //
&& "an attempt to get a member with an incorrect instance type"
);
auto&& return_value = inst.cast<const class_type>().*member_ptr;
auto&& return_value = inst.cast<const class_type>(registry).*member_ptr;
if constexpr ( as_copy ) {
return uvalue{META_HPP_FWD(return_value)};
@@ -54,11 +55,11 @@ namespace meta_hpp::detail
}
} else {
META_HPP_ASSERT( //
inst.can_cast_to<class_type>() //
inst.can_cast_to<class_type>(registry) //
&& "an attempt to get a member with an incorrect instance type"
);
auto&& return_value = inst.cast<class_type>().*member_ptr;
auto&& return_value = inst.cast<class_type>(registry).*member_ptr;
if constexpr ( as_copy ) {
return uvalue{META_HPP_FWD(return_value)};
@@ -75,23 +76,27 @@ namespace meta_hpp::detail
}
template < member_pointer_kind Member >
bool raw_member_is_gettable_with(const uinst_base& inst) {
bool raw_member_is_gettable_with(type_registry& registry, const uinst_base& inst) {
using mt = member_traits<Member>;
using class_type = typename mt::class_type;
return inst.can_cast_to<const class_type>();
return inst.can_cast_to<const class_type>(registry);
}
}
namespace meta_hpp::detail
{
template < member_pointer_kind Member >
void raw_member_setter([[maybe_unused]] Member member_ptr, const uinst& inst, const uarg& arg) {
void raw_member_setter(type_registry& registry, Member member_ptr, const uinst& inst, const uarg& arg) {
using mt = member_traits<Member>;
using class_type = typename mt::class_type;
using value_type = typename mt::value_type;
if constexpr ( std::is_const_v<value_type> ) {
(void)registry;
(void)member_ptr;
(void)inst;
(void)arg;
META_HPP_ASSERT(false && "an attempt to set a constant member");
} else {
META_HPP_ASSERT( //
@@ -100,31 +105,34 @@ namespace meta_hpp::detail
);
META_HPP_ASSERT( //
inst.can_cast_to<class_type>() //
inst.can_cast_to<class_type>(registry) //
&& "an attempt to set a member with an incorrect instance type"
);
META_HPP_ASSERT( //
arg.can_cast_to<value_type>() //
arg.can_cast_to<value_type>(registry) //
&& "an attempt to set a member with an incorrect argument type"
);
inst.cast<class_type>().*member_ptr = arg.cast<value_type>();
inst.cast<class_type>(registry).*member_ptr = arg.cast<value_type>(registry);
}
}
template < member_pointer_kind Member >
bool raw_member_is_settable_with(const uinst_base& inst, const uarg_base& arg) {
bool raw_member_is_settable_with(type_registry& registry, const uinst_base& inst, const uarg_base& arg) {
using mt = member_traits<Member>;
using class_type = typename mt::class_type;
using value_type = typename mt::value_type;
if constexpr ( std::is_const_v<value_type> ) {
(void)registry;
(void)inst;
(void)arg;
return false;
} else {
return !inst.is_inst_const() //
&& inst.can_cast_to<class_type>() //
&& arg.can_cast_to<value_type>(); //
&& inst.can_cast_to<class_type>(registry) //
&& arg.can_cast_to<value_type>(registry); //
}
}
}
@@ -132,27 +140,31 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < member_policy_kind Policy, member_pointer_kind Member >
member_state::getter_impl make_member_getter(Member member_ptr) {
return [member_ptr](const uinst& inst) { //
return raw_member_getter<Policy>(member_ptr, inst);
member_state::getter_impl make_member_getter(type_registry& registry, Member member_ptr) {
return [&registry, member_ptr](const uinst& inst) { //
return raw_member_getter<Policy>(registry, member_ptr, inst);
};
}
template < member_pointer_kind Member >
member_state::is_gettable_with_impl make_member_is_gettable_with() {
return &raw_member_is_gettable_with<Member>;
}
template < member_pointer_kind Member >
member_state::setter_impl make_member_setter(Member member_ptr) {
return [member_ptr](const uinst& inst, const uarg& arg) { //
return raw_member_setter(member_ptr, inst, arg);
member_state::is_gettable_with_impl make_member_is_gettable_with(type_registry& registry) {
return [&registry](const uinst_base& inst) { //
return raw_member_is_gettable_with<Member>(registry, inst);
};
}
template < member_pointer_kind Member >
member_state::is_settable_with_impl make_member_is_settable_with() {
return &raw_member_is_settable_with<Member>;
member_state::setter_impl make_member_setter(type_registry& registry, Member member_ptr) {
return [&registry, member_ptr](const uinst& inst, const uarg& arg) { //
return raw_member_setter(registry, member_ptr, inst, arg);
};
}
template < member_pointer_kind Member >
member_state::is_settable_with_impl make_member_is_settable_with(type_registry& registry) {
return [&registry](const uinst_base& inst, const uarg_base& arg) { //
return raw_member_is_settable_with<Member>(registry, inst, arg);
};
}
}
@@ -164,11 +176,12 @@ namespace meta_hpp::detail
template < member_policy_kind Policy, member_pointer_kind Member >
member_state_ptr member_state::make(std::string name, Member member_ptr, metadata_map metadata) {
member_state state{member_index{resolve_type<Member>(), std::move(name)}, std::move(metadata)};
state.getter = make_member_getter<Policy>(member_ptr);
state.setter = make_member_setter(member_ptr);
state.is_gettable_with = make_member_is_gettable_with<Member>();
state.is_settable_with = make_member_is_settable_with<Member>();
type_registry& registry{type_registry::instance()};
member_state state{member_index{registry.resolve_type<Member>(), std::move(name)}, std::move(metadata)};
state.getter = make_member_getter<Policy>(registry, member_ptr);
state.setter = make_member_setter(registry, member_ptr);
state.is_gettable_with = make_member_is_gettable_with<Member>(registry);
state.is_settable_with = make_member_is_settable_with<Member>(registry);
return make_intrusive<member_state>(std::move(state));
}
}
@@ -186,7 +199,8 @@ namespace meta_hpp
template < typename Instance >
uvalue member::get(Instance&& instance) const {
using namespace detail;
const uinst vinst{std::forward<Instance>(instance)};
type_registry& registry{type_registry::instance()};
const uinst vinst{registry, std::forward<Instance>(instance)};
return state_->getter(vinst);
}
@@ -211,8 +225,9 @@ namespace meta_hpp
template < typename Instance, typename Value >
void member::set(Instance&& instance, Value&& value) const {
using namespace detail;
const uinst vinst{std::forward<Instance>(instance)};
const uarg vvalue{std::forward<Value>(value)};
type_registry& registry{type_registry::instance()};
const uinst vinst{registry, std::forward<Instance>(instance)};
const uarg vvalue{registry, std::forward<Value>(value)};
state_->setter(vinst, vvalue);
}
@@ -238,30 +253,34 @@ namespace meta_hpp
template < typename Instance >
[[nodiscard]] bool member::is_gettable_with() const noexcept {
using namespace detail;
const uinst_base vinst{type_list<Instance>{}};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, type_list<Instance>{}};
return state_->is_gettable_with(vinst);
}
template < typename Instance >
[[nodiscard]] bool member::is_gettable_with(Instance&& instance) const noexcept {
using namespace detail;
const uinst_base vinst{std::forward<Instance>(instance)};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, std::forward<Instance>(instance)};
return state_->is_gettable_with(vinst);
}
template < typename Instance, typename Value >
[[nodiscard]] bool member::is_settable_with() const noexcept {
using namespace detail;
const uinst_base vinst{type_list<Instance>{}};
const uarg_base vvalue{type_list<Value>{}};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, type_list<Instance>{}};
const uarg_base vvalue{registry, type_list<Value>{}};
return state_->is_settable_with(vinst, vvalue);
}
template < typename Instance, typename Value >
[[nodiscard]] bool member::is_settable_with(Instance&& instance, Value&& value) const noexcept {
using namespace detail;
const uinst_base vinst{std::forward<Instance>(instance)};
const uarg_base vvalue{std::forward<Value>(value)};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, std::forward<Instance>(instance)};
const uarg_base vvalue{registry, std::forward<Value>(value)};
return state_->is_settable_with(vinst, vvalue);
}
}

53
headers/meta.hpp/meta_states/method.hpp
View File

@@ -9,6 +9,7 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_detail/value_utilities/uinst.hpp"
#include "../meta_types/method_type.hpp"
@@ -16,7 +17,7 @@
namespace meta_hpp::detail
{
template < method_policy_kind Policy, method_pointer_kind Method >
uvalue raw_method_invoke(Method method_ptr, const uinst& inst, std::span<const uarg> args) {
uvalue raw_method_invoke(type_registry& registry, Method method_ptr, const uinst& inst, std::span<const uarg> args) {
using mt = method_traits<Method>;
using return_type = typename mt::return_type;
using qualified_type = typename mt::qualified_type;
@@ -42,18 +43,18 @@ namespace meta_hpp::detail
);
META_HPP_ASSERT( //
inst.can_cast_to<qualified_type>() //
inst.can_cast_to<qualified_type>(registry) //
&& "an attempt to call a method with an incorrect instance type"
);
META_HPP_ASSERT( //
can_cast_all_uargs<argument_types>(args) //
can_cast_all_uargs<argument_types>(registry, args) //
&& "an attempt to call a method with incorrect argument types"
);
return call_with_uargs<argument_types>(args, [method_ptr, &inst](auto&&... all_args) {
return call_with_uargs<argument_types>(registry, args, [method_ptr, &inst, &registry](auto&&... all_args) {
if constexpr ( std::is_void_v<return_type> ) {
(inst.cast<qualified_type>().*method_ptr)(META_HPP_FWD(all_args)...);
(inst.cast<qualified_type>(registry).*method_ptr)(META_HPP_FWD(all_args)...);
return uvalue{};
}
@@ -63,36 +64,38 @@ namespace meta_hpp::detail
}
if constexpr ( !std::is_void_v<return_type> ) {
return_type&& result = (inst.cast<qualified_type>().*method_ptr)(META_HPP_FWD(all_args)...);
return_type&& result = (inst.cast<qualified_type>(registry).*method_ptr)(META_HPP_FWD(all_args)...);
return ref_as_ptr ? uvalue{std::addressof(result)} : uvalue{META_HPP_FWD(result)};
}
});
}
template < method_pointer_kind Method >
bool raw_method_is_invocable_with(const uinst_base& inst, std::span<const uarg_base> args) {
bool raw_method_is_invocable_with(type_registry& registry, const uinst_base& inst, std::span<const uarg_base> args) {
using mt = method_traits<Method>;
using qualified_type = typename mt::qualified_type;
using argument_types = typename mt::argument_types;
return args.size() == mt::arity //
&& inst.can_cast_to<qualified_type>() //
&& can_cast_all_uargs<argument_types>(args);
&& inst.can_cast_to<qualified_type>(registry) //
&& can_cast_all_uargs<argument_types>(registry, args);
}
}
namespace meta_hpp::detail
{
template < method_policy_kind Policy, method_pointer_kind Method >
method_state::invoke_impl make_method_invoke(Method method_ptr) {
return [method_ptr](const uinst& inst, std::span<const uarg> args) {
return raw_method_invoke<Policy>(method_ptr, inst, args);
method_state::invoke_impl make_method_invoke(type_registry& registry, Method method_ptr) {
return [&registry, method_ptr](const uinst& inst, std::span<const uarg> args) {
return raw_method_invoke<Policy>(registry, method_ptr, inst, args);
};
}
template < method_pointer_kind Method >
method_state::is_invocable_with_impl make_method_is_invocable_with() {
return &raw_method_is_invocable_with<Method>;
method_state::is_invocable_with_impl make_method_is_invocable_with(type_registry& registry) {
return [&registry](const uinst_base& inst, std::span<const uarg_base> args) {
return raw_method_is_invocable_with<Method>(registry, inst, args);
};
}
template < method_pointer_kind Method >
@@ -119,9 +122,10 @@ namespace meta_hpp::detail
template < method_policy_kind Policy, method_pointer_kind Method >
method_state_ptr method_state::make(std::string name, Method method_ptr, metadata_map metadata) {
method_state state{method_index{resolve_type<Method>(), std::move(name)}, std::move(metadata)};
state.invoke = make_method_invoke<Policy>(method_ptr);
state.is_invocable_with = make_method_is_invocable_with<Method>();
type_registry& registry{type_registry::instance()};
method_state state{method_index{registry.resolve_type<Method>(), std::move(name)}, std::move(metadata)};
state.invoke = make_method_invoke<Policy>(registry, method_ptr);
state.is_invocable_with = make_method_is_invocable_with<Method>(registry);
state.arguments = make_method_arguments<Method>();
return make_intrusive<method_state>(std::move(state));
}
@@ -140,8 +144,9 @@ namespace meta_hpp
template < typename Instance, typename... Args >
uvalue method::invoke(Instance&& instance, Args&&... args) const {
using namespace detail;
const uinst vinst{std::forward<Instance>(instance)};
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const uinst vinst{registry, std::forward<Instance>(instance)};
const std::array<uarg, sizeof...(Args)> vargs{uarg{registry, std::forward<Args>(args)}...};
return state_->invoke(vinst, vargs);
}
@@ -161,16 +166,18 @@ namespace meta_hpp
template < typename Instance, typename... Args >
bool method::is_invocable_with() const noexcept {
using namespace detail;
const uinst_base vinst{type_list<Instance>{}};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, type_list<Instance>{}};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, type_list<Args>{}}...};
return state_->is_invocable_with(vinst, vargs);
}
template < typename Instance, typename... Args >
bool method::is_invocable_with(Instance&& instance, Args&&... args) const noexcept {
using namespace detail;
const uinst_base vinst{std::forward<Instance>(instance)};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
type_registry& registry{type_registry::instance()};
const uinst_base vinst{registry, std::forward<Instance>(instance)};
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{registry, std::forward<Args>(args)}...};
return state_->is_invocable_with(vinst, vargs);
}

10
headers/meta.hpp/meta_states/scope.hpp
View File

@@ -7,15 +7,14 @@
#pragma once
#include "../meta_base.hpp"
#include "../meta_registry.hpp"
#include "../meta_states.hpp"
#include "../meta_types.hpp"
#include "../meta_types/class_type.hpp"
#include "../meta_types/enum_type.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_states/function.hpp"
#include "../meta_states/variable.hpp"
#include "../meta_types/class_type.hpp"
#include "../meta_types/enum_type.hpp"
namespace meta_hpp::detail
{
@@ -74,7 +73,8 @@ namespace meta_hpp
template < typename... Args >
function scope::get_function_with(std::string_view name) const noexcept {
return get_function_with(name, {resolve_type<Args>()...});
detail::type_registry& registry{detail::type_registry::instance()};
return get_function_with(name, {registry.resolve_type<Args>()...});
}
template < typename Iter >

54
headers/meta.hpp/meta_states/variable.hpp
View File

@@ -9,13 +9,14 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
#include "../meta_types/pointer_type.hpp"
namespace meta_hpp::detail
{
template < variable_policy_kind Policy, pointer_kind Pointer >
uvalue raw_variable_getter(Pointer variable_ptr) {
uvalue raw_variable_getter(type_registry&, Pointer variable_ptr) {
using pt = pointer_traits<Pointer>;
using data_type = typename pt::data_type;
@@ -47,31 +48,36 @@ namespace meta_hpp::detail
}
template < pointer_kind Pointer >
void raw_variable_setter([[maybe_unused]] Pointer variable_ptr, const uarg& arg) {
void raw_variable_setter(type_registry& registry, Pointer variable_ptr, const uarg& arg) {
using pt = pointer_traits<Pointer>;
using data_type = typename pt::data_type;
if constexpr ( std::is_const_v<data_type> ) {
(void)registry;
(void)variable_ptr;
(void)arg;
META_HPP_ASSERT(false && "an attempt to set a constant variable");
} else {
META_HPP_ASSERT( //
arg.can_cast_to<data_type>() //
arg.can_cast_to<data_type>(registry) //
&& "an attempt to set a variable with an incorrect argument type"
);
*variable_ptr = arg.cast<data_type>();
*variable_ptr = arg.cast<data_type>(registry);
}
}
template < pointer_kind Pointer >
bool raw_variable_is_settable_with(const uarg_base& arg) {
bool raw_variable_is_settable_with(type_registry& registry, const uarg_base& arg) {
using pt = pointer_traits<Pointer>;
using data_type = typename pt::data_type;
if constexpr ( std::is_const_v<data_type> ) {
(void)registry;
(void)arg;
return false;
} else {
return arg.can_cast_to<data_type>();
return arg.can_cast_to<data_type>(registry);
}
}
}
@@ -79,22 +85,24 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < variable_policy_kind Policy, pointer_kind Pointer >
variable_state::getter_impl make_variable_getter(Pointer variable_ptr) {
return [variable_ptr]() { //
return raw_variable_getter<Policy>(variable_ptr);
variable_state::getter_impl make_variable_getter(type_registry& registry, Pointer variable_ptr) {
return [&registry, variable_ptr]() { //
return raw_variable_getter<Policy>(registry, variable_ptr);
};
}
template < pointer_kind Pointer >
variable_state::setter_impl make_variable_setter(Pointer variable_ptr) {
return [variable_ptr](const uarg& arg) { //
return raw_variable_setter(variable_ptr, arg);
variable_state::setter_impl make_variable_setter(type_registry& registry, Pointer variable_ptr) {
return [&registry, variable_ptr](const uarg& arg) { //
return raw_variable_setter(registry, variable_ptr, arg);
};
}
template < pointer_kind Pointer >
variable_state::is_settable_with_impl make_variable_is_settable_with() {
return &raw_variable_is_settable_with<Pointer>;
variable_state::is_settable_with_impl make_variable_is_settable_with(type_registry& registry) {
return [&registry](const uarg_base& arg) { //
return raw_variable_is_settable_with<Pointer>(registry, arg);
};
}
}
@@ -106,10 +114,11 @@ namespace meta_hpp::detail
template < variable_policy_kind Policy, pointer_kind Pointer >
variable_state_ptr variable_state::make(std::string name, Pointer variable_ptr, metadata_map metadata) {
variable_state state{variable_index{resolve_type<Pointer>(), std::move(name)}, std::move(metadata)};
state.getter = make_variable_getter<Policy>(variable_ptr);
state.setter = make_variable_setter(variable_ptr);
state.is_settable_with = make_variable_is_settable_with<Pointer>();
type_registry& registry{type_registry::instance()};
variable_state state{variable_index{registry.resolve_type<Pointer>(), std::move(name)}, std::move(metadata)};
state.getter = make_variable_getter<Policy>(registry, variable_ptr);
state.setter = make_variable_setter(registry, variable_ptr);
state.is_settable_with = make_variable_is_settable_with<Pointer>(registry);
return make_intrusive<variable_state>(std::move(state));
}
}
@@ -145,7 +154,8 @@ namespace meta_hpp
template < typename Value >
void variable::set(Value&& value) const {
using namespace detail;
const uarg vvalue{std::forward<Value>(value)};
type_registry& registry{type_registry::instance()};
const uarg vvalue{registry, std::forward<Value>(value)};
state_->setter(vvalue);
}
@@ -170,14 +180,16 @@ namespace meta_hpp
template < typename Value >
bool variable::is_settable_with() const noexcept {
using namespace detail;
const uarg_base vvalue{type_list<Value>{}};
type_registry& registry{type_registry::instance()};
const uarg_base vvalue{registry, type_list<Value>{}};
return state_->is_settable_with(vvalue);
}
template < typename Value >
bool variable::is_settable_with(Value&& value) const noexcept {
using namespace detail;
const uarg_base vvalue{std::forward<Value>(value)};
type_registry& registry{type_registry::instance()};
const uarg_base vvalue{registry, std::forward<Value>(value)};
return state_->is_settable_with(vvalue);
}
}

9
headers/meta.hpp/meta_types/class_type.hpp
View File

@@ -258,7 +258,8 @@ namespace meta_hpp
template < typename... Args >
constructor class_type::get_constructor_with() const noexcept {
return get_constructor_with({resolve_type<Args>()...});
detail::type_registry& registry{detail::type_registry::instance()};
return get_constructor_with({registry.resolve_type<Args>()...});
}
template < typename Iter >
@@ -297,7 +298,8 @@ namespace meta_hpp
template < typename... Args >
function class_type::get_function_with(std::string_view name) const noexcept {
return get_function_with(name, {resolve_type<Args>()...});
detail::type_registry& registry{detail::type_registry::instance()};
return get_function_with(name, {registry.resolve_type<Args>()...});
}
template < typename Iter >
@@ -336,7 +338,8 @@ namespace meta_hpp
template < typename... Args >
method class_type::get_method_with(std::string_view name) const noexcept {
return get_method_with(name, {resolve_type<Args>()...});
detail::type_registry& registry{detail::type_registry::instance()};
return get_method_with(name, {registry.resolve_type<Args>()...});
}
template < typename Iter >

18
headers/meta.hpp/meta_uvalue/uvalue.hpp
View File

@@ -495,8 +495,11 @@ namespace meta_hpp
auto uvalue::try_get_as() noexcept -> std::conditional_t<detail::pointer_kind<T>, T, T*> {
static_assert(std::is_same_v<T, std::decay_t<T>>);
using detail::type_registry;
type_registry& registry{type_registry::instance()};
const any_type& from_type = get_type();
const any_type& to_type = resolve_type<T>();
const any_type& to_type = registry.resolve_type<T>();
const auto is_a = [](const any_type& base, const any_type& derived) {
return (base == derived) //
@@ -530,7 +533,7 @@ namespace meta_hpp
const class_type& to_data_class = to_data_type.as_class();
const class_type& from_data_class = from_data_type.as_class();
void* to_ptr = detail::pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
void* to_ptr = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class);
return static_cast<T>(to_ptr);
}
}
@@ -547,7 +550,7 @@ namespace meta_hpp
const class_type& to_class = to_type.as_class();
const class_type& from_class = from_type.as_class();
T* to_ptr = static_cast<T*>(detail::pointer_upcast(get_data(), from_class, to_class));
T* to_ptr = static_cast<T*>(detail::pointer_upcast(registry, get_data(), from_class, to_class));
return to_ptr;
}
}
@@ -560,8 +563,11 @@ namespace meta_hpp
auto uvalue::try_get_as() const noexcept -> std::conditional_t<detail::pointer_kind<T>, T, const T*> {
static_assert(std::is_same_v<T, std::decay_t<T>>);
using detail::type_registry;
type_registry& registry{type_registry::instance()};
const any_type& from_type = get_type();
const any_type& to_type = resolve_type<T>();
const any_type& to_type = registry.resolve_type<T>();
const auto is_a = [](const any_type& base, const any_type& derived) {
return (base == derived) //
@@ -595,7 +601,7 @@ namespace meta_hpp
const class_type& to_data_class = to_data_type.as_class();
const class_type& from_data_class = from_data_type.as_class();
void* to_ptr = detail::pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
void* to_ptr = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class);
return static_cast<T>(to_ptr);
}
}
@@ -612,7 +618,7 @@ namespace meta_hpp
const class_type& to_class = to_type.as_class();
const class_type& from_class = from_type.as_class();
const T* to_ptr = static_cast<const T*>(detail::pointer_upcast(get_data(), from_class, to_class));
const T* to_ptr = static_cast<const T*>(detail::pointer_upcast(registry, get_data(), from_class, to_class));
return to_ptr;
}
}