23 #ifndef REFL_INCLUDE_HPP
24 #define REFL_INCLUDE_HPP
33 #include <type_traits>
41 #pragma warning( disable : 4003
)
44 #if defined(__clang__
)
45 #if __has_feature
(cxx_rtti)
46 #define REFL_RTTI_ENABLED
48 #elif defined(__GNUG__)
49 #if defined(__GXX_RTTI)
50 #define REFL_RTTI_ENABLED
52 #elif defined(_MSC_VER)
54 #define REFL_RTTI_ENABLED
89 #define REFL_MAKE_CONST_STRING(CString)
90 (::refl::util::detail::copy_from_unsized<::refl::util::detail::strlen(CString)>(CString))
106 static constexpr size_t
npos =
static_cast<size_t>(-1);
109 static constexpr size_t
size = N;
143 explicit constexpr operator const char*()
const noexcept
159 constexpr const char*
c_str()
const noexcept
167 std::string
str()
const noexcept
175 template <size_t Pos, size_t Count =
npos>
178 static_assert(Pos <= N);
179 constexpr size_t NewSize = std::min(Count, N - Pos);
181 char buf[NewSize + 1]{};
182 for (size_t i = 0; i < NewSize; i++) {
183 buf[i] =
data[Pos + i];
194 template <size_t... Idx>
195 constexpr const_string(
const const_string<N>& other, std::index_sequence<Idx...>)
noexcept
196 :
data{ other.data[Idx]... }
203 template <size_t... Idx>
204 constexpr const_string(
const char(&data)[
sizeof...(Idx) + 1], std::index_sequence<Idx...>)
noexcept
205 :
data{ data[Idx]... }
237 template <size_t N, size_t M>
240 char data[N + M + 1] { };
241 for (size_t i = 0; i < N; i++)
243 for (size_t i = 0; i < M; i++)
244 data[N + i] = b.data[i];
253 template <size_t N, size_t M>
256 return a + make_const_string(b);
264 template <size_t N, size_t M>
267 return make_const_string(a) + b;
275 template <size_t N, size_t M>
278 if constexpr (N != M) {
282 for (size_t i = 0; i < M; i++) {
283 if (a.data[i] != b.data[i]) {
296 template <size_t N, size_t M>
307 template <size_t N, size_t M>
310 return a == make_const_string(b);
318 template <size_t N, size_t M>
321 return a != make_const_string(b);
329 template <size_t N, size_t M>
332 return make_const_string(a) == b;
340 template <size_t N, size_t M>
343 return make_const_string(a) != b;
347 constexpr std::ostream& operator<<(std::ostream& os,
const const_string<N>& str)
noexcept
349 return os << str.c_str();
354 constexpr size_t strlen(
const char*
const str)
356 return *str ? 1 + strlen(str + 1) : 0;
360 constexpr const_string<N> copy_from_unsized(
const char*
const str)
363 for (size_t i = 0; i < N; i++) {
364 cstr.data[i] = str[i];
388 template <
typename... Ts>
392 static constexpr intptr_t
size =
sizeof...(Ts);
397 using util::const_string;
398 using util::make_const_string;
399 using util::type_list;
408 namespace macro_exports
427 using namespace refl::detail::macro_exports;
441 template <
typename T>
445 struct invalid_marker{};
450 template <size_t,
typename>
454 static constexpr size_t member_count{ 0 };
460 static constexpr std::tuple<> attributes{ };
466 template <
typename T>
467 struct type_info__<
const T> :
public type_info__<T> {};
472 template <
typename T>
473 struct type_info__<
volatile T> :
public type_info__<T> {};
478 template <
typename T>
479 struct type_info__<
const volatile T> :
public type_info__<T> {};
524 template <
typename T>
527 typedef std::remove_cv_t<std::remove_reference_t<T>>
type;
535 template <
typename T>
541 template <
typename T>
542 decltype(
typename refl_impl::metadata::type_info__<T>::invalid_marker{}, std::false_type{}) is_reflectable_test(
int);
545 template <
typename T>
546 std::true_type is_reflectable_test(...);
556 template <
typename T>
567 template <
typename T>
568 [[maybe_unused]]
static constexpr bool is_reflectable_v{ is_reflectable<T>::value };
573 template <
typename U>
574 [[maybe_unused]]
static auto is_container_test(
int) ->
decltype(std::declval<U>().begin(), std::declval<U>().end(), std::true_type{});
577 template <
typename U>
578 [[maybe_unused]]
static std::false_type is_container_test(...);
584 template <
typename T>
592 template <
typename T>
593 [[maybe_unused]]
static constexpr bool is_container_v{ is_container<T>::value };
597 template <size_t N,
typename... Ts>
603 static_assert(N > 0,
"Missing arguments list for get<N, Ts...>!");
606 template <size_t N,
typename T,
typename... Ts>
607 struct get<N, T, Ts...> :
public get<N - 1, Ts...>
611 template <
typename T,
typename... Ts>
612 struct get<0, T, Ts...>
617 template <size_t N,
typename T>
620 template <size_t N,
typename T,
typename... Ts>
625 template <
typename T,
typename... Ts>
638 template <size_t,
typename>
645 template <size_t N,
typename... Ts>
654 template <size_t N,
typename TypeList>
655 using get_t =
typename get<N, TypeList>::type;
661 template <size_t N,
typename TypeList>
662 using skip = detail::skip<N, TypeList>;
668 template <size_t N,
typename TypeList>
669 using skip_t =
typename skip<N, TypeList>::type;
671 template <
typename T>
679 template <
template <
typename...>
typename T,
typename... Ts>
680 struct as_type_list<T<Ts...>>
685 template <
typename T>
686 struct as_type_list : as_type_list<remove_qualifiers_t<T>>
696 template <
typename T>
697 using as_type_list_t =
typename as_type_list<T>::type;
702 template <
typename TypeList>
703 using first = get<0, TypeList>;
709 template <
typename TypeList>
710 using first_t =
typename first<TypeList>::type;
715 template <
typename TypeList>
716 using last = get<TypeList::size - 1, TypeList>;
722 template <
typename TypeList>
723 using last_t =
typename last<TypeList>::type;
728 template <
typename TypeList>
729 using tail = skip<1, TypeList>;
735 template <
typename TypeList>
736 using tail_t =
typename tail<TypeList>::type;
740 template <
typename, size_t,
typename>
743 template <
typename... Us>
749 template <
typename... Us,
typename T,
typename... Ts>
755 template <size_t N,
typename... Us,
typename T,
typename... Ts>
765 template <size_t N,
typename TypeList>
771 template <size_t N,
typename TypeList>
772 using take_t =
typename take<N, TypeList>::type;
777 template <
typename TypeList>
778 using init = take<TypeList::size - 1, TypeList>;
784 template <
typename TypeList>
785 using init_t =
typename init<TypeList>::type;
789 template <
typename,
typename>
792 template <
typename... Us>
798 template <
typename... Us,
typename T,
typename... Ts>
809 template <
typename TypeList>
818 template <
typename TypeList>
819 using reverse_t =
typename reverse<TypeList>::type;
821 template <
typename,
typename>
827 template <
typename... Ts,
typename... Us>
837 template <
typename Lhs,
typename Rhs>
838 using concat_t =
typename concat<Lhs, Rhs>::type;
843 template <
typename T,
typename TypeList>
852 template <
typename T,
typename TypeList>
853 using append_t =
typename append<T, TypeList>::type;
855 template <
typename,
typename>
861 template <
typename T,
typename TypeList>
862 struct prepend : concat<
type_list<T>, TypeList>
870 template <
typename T,
typename TypeList>
871 using prepend_t =
typename prepend<T, TypeList>::type;
875 template <
template<
typename>
typename,
typename>
878 template <
template<
typename>
typename Predicate>
879 struct filter_impl<Predicate,
type_list<>>
884 template <
template<
typename>
typename Predicate,
typename Head,
typename ...Tail>
885 struct filter_impl<Predicate,
type_list<Head, Tail...>>
887 using type = std::conditional_t<Predicate<Head>::value,
888 typename prepend<Head,
typename filter_impl<Predicate,
type_list<Tail...>>::type>::type,
889 typename filter_impl<Predicate,
type_list<Tail...>>::type
896 template <
template<
typename>
typename Predicate>
899 template <
typename TypeList>
900 using apply =
typename detail::filter_impl<Predicate, TypeList>::type;
903 template <
template<
typename>
typename,
typename>
906 template <
template<
typename>
typename Mapper>
912 template <
template<
typename>
typename Mapper,
typename Head,
typename ...Tail>
913 struct map_impl<Mapper,
type_list<Head, Tail...>>
915 using type =
typename prepend<
typename Mapper<Head>::type,
916 typename map_impl<Mapper,
type_list<Tail...>>::type>::type;
922 template <
template<
typename>
typename Mapper>
925 template <
typename TypeList>
926 using apply =
typename detail::map_impl<Mapper, TypeList>::type;
930 template <
template<
typename>
typename,
typename>
936 template <
template<
typename>
typename Predicate,
typename... Ts>
947 template <
template<
typename>
typename Predicate,
typename TypeList>
948 using filter_t =
typename filter<Predicate, TypeList>::type;
950 template <
template<
typename>
typename,
typename>
956 template <
template<
typename>
typename Mapper,
typename... Ts>
967 template <
template<
typename>
typename Mapper,
typename... Ts>
968 using map_t =
typename map<Mapper, Ts...>::type;
972 template <
typename T>
973 struct is_instance :
public std::false_type {};
975 template <
template<
typename...>
typename T,
typename... Args>
976 struct is_instance<T<Args...>> :
public std::true_type {};
983 template <
typename T>
992 template <
typename T>
993 [[maybe_unused]]
static constexpr bool is_instance_v{ is_instance<T>::value };
1001 template <
typename T,
template<
typename...>
typename U,
typename... Args>
1002 struct is_same_template
1005 template <
template<
typename...>
typename V,
typename = V<Args...>>
1006 static auto test(
int) -> std::is_same<V<Args...>, T>;
1008 template <
template<
typename...>
typename V>
1009 static std::false_type test(...);
1011 static constexpr bool value{
decltype(test<U>(0))::value};
1014 template <
template<
typename...>
typename T,
typename U>
1015 struct is_instance_of :
public std::false_type {};
1017 template <
template<
typename...>
typename T,
template<
typename...>
typename U,
typename... Args>
1018 struct is_instance_of<T, U<Args...>> :
public is_same_template<U<Args...>, T, Args...>
1028 template <
template<
typename...>
typename T,
typename U>
1037 template <
template<
typename...>
typename T,
typename U>
1038 [[maybe_unused]]
static constexpr bool is_instance_of_v{ is_instance_of<T, U>::value };
1042 template <
typename,
typename>
1043 struct contains_impl;
1045 template <
typename T,
typename... Ts>
1046 struct contains_impl<T,
type_list<Ts...>> : std::disjunction<std::is_same<std::remove_cv_t<Ts>, T>...>
1050 template <
template<
typename...>
typename,
typename>
1051 struct contains_instance_impl;
1053 template <
template<
typename...>
typename T,
typename... Ts>
1058 template <
typename,
typename>
1059 struct contains_base_impl;
1061 template <
typename T,
typename... Ts>
1062 struct contains_base_impl<T,
type_list<Ts...>> : std::disjunction<std::is_base_of<T, std::remove_cv_t<Ts>>...>
1071 template <
typename T,
typename TypeList>
1072 struct contains : detail::contains_impl<std::remove_cv_t<T>, TypeList>
1080 template <
typename T,
typename TypeList>
1081 [[maybe_unused]]
static constexpr bool contains_v = contains<T, TypeList>::value;
1087 template <
template<
typename...>
typename T,
typename TypeList>
1096 template <
template<
typename...>
typename T,
typename TypeList>
1097 [[maybe_unused]]
static constexpr bool contains_instance_v = contains_instance<T, TypeList>::value;
1103 template <
typename T,
typename TypeList>
1104 struct contains_base : detail::contains_base_impl<std::remove_cv_t<T>, TypeList>
1112 template <
typename T,
typename TypeList>
1113 [[maybe_unused]]
static constexpr bool contains_base_v = contains_base<T, TypeList>::value;
1181 template <
typename T>
1182 class type_descriptor;
1189 template <
typename T>
1190 auto member_type_test(
int) ->
decltype(
typename T::member_type{}, std::true_type{});
1192 template <
typename T>
1193 std::false_type member_type_test(...);
1199 template <
typename T>
1207 template <
typename T>
1208 [[maybe_unused]]
static constexpr bool is_member_v{ is_member<T>::value };
1212 template <
typename T>
1213 struct is_field_2 : std::is_base_of<
typename T::member_type,
member::
field>
1221 template <
typename T>
1229 template <
typename T>
1230 [[maybe_unused]]
static constexpr bool is_field_v{ is_field<T>::value };
1234 template <
typename T>
1235 struct is_function_2 : std::is_base_of<
typename T::member_type,
member::
function>
1243 template <
typename T>
1251 template <
typename T>
1252 [[maybe_unused]]
static constexpr bool is_function_v{ is_function<T>::value };
1258 template <
typename T>
1267 template <
typename T>
1273 template <
typename T>
1281 template <
typename T>
1282 [[maybe_unused]]
static constexpr bool is_descriptor_v{ is_descriptor<T>::value };
1295 template <
typename T, size_t N>
1300 typedef typename refl_impl::metadata::type_info__<T>::
template member<N>
member;
1326 template <
typename Member>
1327 struct static_field_invoker
1329 static constexpr auto invoke() ->
decltype(*Member::pointer)
1331 return *Member::pointer;
1334 template <
typename U,
typename M = Member, std::enable_if_t<M::is_writable,
int> = 0>
1335 static constexpr auto invoke(U&& value) ->
decltype(*Member::pointer = std::forward<U>(value))
1337 return *Member::pointer = std::forward<U>(value);
1341 template <
typename Member>
1342 struct instance_field_invoker
1344 template <
typename T>
1345 static constexpr auto invoke(T&& target) ->
decltype(target.*(Member::pointer))
1347 return target.*(Member::pointer);
1350 template <
typename T,
typename U,
typename M = Member, std::enable_if_t<M::is_writable,
int> = 0>
1351 static constexpr auto invoke(T&& target, U&& value) ->
decltype(target.*(Member::pointer) = std::forward<U>(value))
1353 return target.*(Member::pointer) = std::forward<U>(value);
1357 template <
typename Member>
1358 static_field_invoker<Member> field_type_switch(std::true_type);
1360 template <
typename Member>
1361 instance_field_invoker<Member> field_type_switch(std::false_type);
1367 template <
typename T, size_t N>
1371 static_assert(
trait::is_field_v<member>);
1379 static constexpr bool is_static{ !std::is_member_object_pointer_v<
decltype(member::pointer)> };
1394 template <
decltype(
nullptr) =
nullptr>
1395 static constexpr decltype(
auto)
get()
noexcept
1397 return *member::pointer;
1401 template <
typename U>
1402 static constexpr decltype(
auto)
get(U&& target)
noexcept
1404 return target.*(member::pointer);
1408 template <
typename... Args>
1409 constexpr auto operator()(Args&&... args)
const noexcept ->
decltype(invoker::invoke(std::forward<Args>(args)...))
1411 return invoker::invoke(std::forward<Args>(args)...);
1418 template <
typename Member>
1419 constexpr decltype(
nullptr) get_function_pointer(...)
1424 template <
typename Member>
1425 constexpr auto get_function_pointer(
int) ->
decltype(Member::pointer())
1427 return Member::pointer();
1430 template <
typename Member,
typename Pointer>
1431 constexpr decltype(
nullptr) resolve_function_pointer(...)
1436 template <
typename Member,
typename Pointer>
1437 constexpr auto resolve_function_pointer(
int) ->
decltype(Member::
template resolve<Pointer>())
1439 return Member::
template resolve<Pointer>();
1446 template <
typename T, size_t N>
1450 static_assert(
trait::is_function_v<member>);
1459 template <
typename... Args>
1460 static constexpr auto invoke(Args&&... args) ->
decltype(member::invoke(std::declval<Args>()...))
1462 return member::invoke(std::forward<Args>(args)...);
1466 template <
typename... Args>
1467 using return_type =
decltype(member::invoke(std::declval<Args>()...));
1470 template <
typename... Args>
1471 constexpr auto operator()(Args&&... args)
const ->
decltype(invoke(std::declval<Args>()...))
1473 return invoke(std::forward<Args>(args)...);
1479 static constexpr auto pointer{ detail::get_function_pointer<member>(0) };
1490 template <
typename Pointer>
1493 return !std::is_same_v<
decltype(resolve<Pointer>()),
decltype(
nullptr)>;
1500 template <
typename Pointer>
1503 return detail::resolve_function_pointer<member, Pointer>(0);
1510 template <
typename T, size_t N>
1511 using make_descriptor = std::conditional_t<
refl::
trait::is_field_v<
typename refl_impl::metadata::type_info__<T>::
template member<N>>,
1513 std::conditional_t<
refl::
trait::is_function_v<
typename refl_impl::metadata::type_info__<T>::
template member<N>>,
1518 template <
typename T, size_t... Idx>
1519 type_list<make_descriptor<T, Idx>...> enumerate_members(std::index_sequence<Idx...>);
1524 template <
typename T>
1525 using member_list =
decltype(detail::enumerate_members<T>(std::make_index_sequence<refl_impl::metadata::type_info__<T>::member_count>{}));
1528 template <
typename T>
1529 class type_descriptor
1533 static_assert(
refl::
trait::is_reflectable_v<T>,
"This type does not support reflection!");
1535 typedef refl_impl::metadata::type_info__<T> type_info;
1552 static constexpr const auto name{ type_info::name };
1566 template <
typename T>
1569 return trait::is_reflectable_v<T>;
1573 template <
typename T>
1576 return trait::is_reflectable_v<T>;
1580 template<
typename T>
1587 template<
typename T>
1588 constexpr type_descriptor<T>
reflect(
const T&)
noexcept
1599 template <
typename T =
int,
typename... Ts>
1609 template <
typename T>
1618 template <
typename T>
1627 template <
typename T>
1638 template <
typename T,
typename... Ts>
1639 constexpr std::array<T,
sizeof...(Ts)>
to_array(
const std::tuple<Ts...>& tuple)
noexcept
1641 return std::apply([](
auto&& ... args) -> std::array<T,
sizeof...(Ts)> {
return { std::forward<
decltype(args)>(args)... }; }, tuple);
1647 template <
typename T>
1648 constexpr std::array<T, 0>
to_array(
const std::tuple<>&)
noexcept
1655 template <
typename T, size_t... Idx>
1656 constexpr auto to_tuple([[maybe_unused]]
const std::array<T,
sizeof...(Idx)>& array, std::index_sequence<Idx...>)
noexcept
1658 if constexpr (
sizeof...(Idx) == 0)
return std::tuple<>{};
1659 else return std::make_tuple(std::get<Idx>(array)...);
1666 template <
typename T, size_t N>
1667 constexpr auto to_tuple(
const std::array<T, N>& array)
noexcept
1669 return detail::to_tuple<T>(array, std::make_index_sequence<N>{});
1674 template <
typename F,
typename... Carry>
1675 constexpr auto eval_in_order_to_tuple(
type_list<>, std::index_sequence<>, F&&, Carry&&... carry)
1677 if constexpr (
sizeof...(Carry) == 0)
return std::tuple<>{};
1678 else return std::make_tuple(std::forward<Carry>(carry)...);
1685 template <
typename F,
typename T,
typename... Ts, size_t I, size_t... Idx,
typename... Carry>
1686 constexpr auto eval_in_order_to_tuple(
type_list<T, Ts...>, std::index_sequence<I, Idx...>, F&& f, Carry&&... carry)
1688 static_assert(std::is_trivial_v<T>,
"Argument is a non-trivial type!");
1690 if constexpr (std::is_invocable_v<F, T, size_t>) {
1691 return eval_in_order_to_tuple(
1693 std::index_sequence<Idx...>{},
1695 std::forward<Carry>(carry)...,
1700 return eval_in_order_to_tuple(
1702 std::index_sequence<Idx...>{},
1704 std::forward<Carry>(carry)...,
1715 template <
typename F,
typename... Ts>
1718 return detail::eval_in_order_to_tuple(list, std::make_index_sequence<
sizeof...(Ts)>{}, std::forward<F>(f));
1725 template <
typename T,
typename F,
typename... Ts>
1728 return to_array<T>(map_to_tuple(list, std::forward<F>(f)));
1735 template <
typename F,
typename... Ts>
1738 map_to_tuple(list, [&](
auto&&... args) ->
decltype(f(std::forward<
decltype(args)>(args)...), 0)
1740 f(std::forward<
decltype(args)>(args)...);
1748 template <
typename R,
typename F,
typename... Ts>
1751 return std::forward<R>(initial_value);
1760 template <
typename R,
typename F,
typename T,
typename... Ts>
1763 static_assert(std::is_trivial_v<T>,
"Argument is a non-trivial type!");
1767 std::forward<std::invoke_result_t<F&&, R&&, T&&>>(
1768 f(std::forward<R>(initial_value), T {})));
1776 template <
typename F,
typename... Ts>
1779 return accumulate<size_t>(list,
1780 [&](size_t acc,
const auto& t) -> size_t {
return acc + (f(t) ? 1 : 0); },
1786 template <
typename F,
typename... Carry>
1792 template <
typename F,
typename T,
typename... Ts,
typename... Carry>
1795 static_assert(std::is_trivial_v<T>,
"Argument is a non-trivial type!");
1796 if constexpr (f(T{})) {
1809 template <
typename F,
typename... Ts>
1812 return decltype(detail::filter(std::forward<F>(f), list,
type_list<>{}))();
1819 template <
typename F,
typename... Ts>
1822 using result_list =
decltype(detail::filter(std::forward<F>(f), list,
type_list<>{}));
1823 static_assert(result_list::size != 0,
"find_first did not match anything!");
1824 return trait::get_t<0, result_list>{};
1832 template <
typename F,
typename... Ts>
1835 using result_list =
decltype(detail::filter(std::forward<F>(f), list,
type_list<>{}));
1836 static_assert(result_list::size != 0,
"find_one did not match anything!");
1837 static_assert(result_list::size == 1,
"Cannot resolve multiple matches in find_one!");
1838 return trait::get_t<0, result_list>{};
1845 template <
typename F,
typename... Ts>
1848 using result_list =
decltype(detail::filter(std::forward<F>(f), list,
type_list<>{}));
1849 return result_list::size > 0;
1855 template <
typename... Ts,
typename F>
1863 template <
template<
typename...>
typename T, ptrdiff_t N,
typename... Ts>
1864 constexpr ptrdiff_t index_of_template()
noexcept
1866 if constexpr (
sizeof...(Ts) <= N)
1876 return index_of_template<T, N + 1, Ts...>();
1880 template <
template<
typename...>
typename T,
typename... Ts>
1881 constexpr ptrdiff_t index_of_template()
noexcept
1883 if (!(... ||
trait::is_instance_of_v<T, Ts>))
return -1;
1884 return index_of_template<T, 0, Ts...>();
1889 template <size_t N,
typename... Ts>
1890 constexpr auto&
get(std::tuple<Ts...>& ts)
noexcept
1892 return std::get<N>(ts);
1896 template <size_t N,
typename... Ts>
1897 constexpr const auto&
get(
const std::tuple<Ts...>& ts)
noexcept
1899 return std::get<N>(ts);
1903 template <
typename T,
typename... Ts>
1904 constexpr T&
get(std::tuple<Ts...>& ts)
noexcept
1906 return std::get<T>(ts);
1910 template <
typename T,
typename... Ts>
1911 constexpr const T&
get(
const std::tuple<Ts...>& ts)
noexcept
1913 return std::get<T>(ts);
1917 template <
template<
typename...>
typename T,
typename... Ts>
1920 static_assert((... ||
trait::is_instance_of_v<T, Ts>),
"The tuple does not contain a type that is a template instance of T!");
1921 constexpr size_t idx =
static_cast<size_t>(detail::index_of_template<T, Ts...>());
1922 return std::get<idx>(ts);
1926 template <
template<
typename...>
typename T,
typename... Ts>
1929 static_assert((... ||
trait::is_instance_of_v<T, Ts>),
"The tuple does not contain a type that is a template instance of T!");
1930 constexpr size_t idx =
static_cast<size_t>(detail::index_of_template<T, Ts...>());
1931 return std::get<idx>(ts);
1960 template <
typename F>
1974 template <
typename... Ts>
1987 template <
typename... Ts>
1988 [[maybe_unused]]
static constexpr base_types<Ts...> bases{ };
1994 namespace macro_exports
1996 using attr::property;
2005 template <
typename T>
2012 template <
typename T>
2013 [[maybe_unused]]
static constexpr bool is_property_v{ is_property<T>::value };
2023 template <
typename T>
2026 return trait::is_field_v<T>;
2034 template <
typename T>
2037 return trait::is_function_v<T>;
2045 template <
typename T>
2048 return trait::is_type_v<T>;
2054 template <
typename A,
typename T>
2057 return trait::contains_base_v<A,
typename T::attribute_types>;
2063 template <
template<
typename...>
typename A,
typename T>
2064 constexpr bool has_attribute(
const T)
noexcept
2066 return trait::contains_instance_v<A,
trait::as_type_list_t<
typename T::attribute_types>>;
2072 template <
typename A,
typename T>
2075 return util::get<A>(t.attributes);
2081 template <
template<
typename...>
typename A,
typename T>
2084 return util::get_instance<A>(t.attributes);
2093 template <
typename T>
2105 template <
typename T>
2115 template <
typename T>
2123 template <
typename T>
2126 if constexpr (
trait::is_property_v<T>) {
2127 if constexpr (std::is_invocable_v<T,
const typename T::declaring_type&>) {
2128 using return_type =
typename T::
template return_type<
const typename T::declaring_type&>;
2129 return !std::is_void_v<return_type>;
2136 return trait::is_field_v<T>;
2143 template <
typename T>
2146 if constexpr (
trait::is_property_v<T>) {
2147 return std::is_invocable_v<T,
typename T::declaring_type&, detail::placeholder>;
2149 else if constexpr (
trait::is_field_v<T>) {
2150 return !std::is_const_v<
typename trait::remove_qualifiers_t<T>::value_type>;
2159 template <
typename T>
2160 struct get_type_descriptor
2162 typedef type_descriptor<T> type;
2172 template <
typename T>
2185 template <
typename T>
2188 static_assert(has_bases(t),
"Target type does not have a bases<A, B, ...> attribute.");
2191 using base_types =
typename decltype(bases)::list_type;
2192 return trait::map_t<detail::get_type_descriptor, base_types>{};
2198 template <
typename T>
2201 static const std::string name(std::string(t.declarator.name) +
"::" + t.name.str());
2202 return name.c_str();
2207 constexpr bool is_upper(
char ch)
2209 return ch >=
'A' && ch <=
'Z';
2212 constexpr char to_upper(
char ch)
2214 return ch >=
'a' && ch <=
'z'
2215 ?
char(ch + (
'A' -
'a'))
2219 constexpr char to_lower(
char ch)
2221 return ch >=
'A' && ch <=
'Z'
2222 ?
char(ch + (
'a' -
'A'))
2226 template <
typename T,
bool PreferUpper>
2227 constexpr auto normalize_bare_accessor_name()
2229 constexpr auto str = T::name.
template substr<3>();
2230 if constexpr (str.data[0] ==
'_') {
2231 return str.
template substr<1>();
2233 else if constexpr (!PreferUpper && str.data[0] >=
'A' && str.data[0] <=
'Z') {
2234 constexpr char s[2]{ to_lower(str.data[0]) ,
'\0' };
2235 return s + str.
template substr<1>();
2237 else if constexpr (PreferUpper) {
2238 constexpr char s[2]{ to_upper(str.data[0]) ,
'\0' };
2239 return s + str.
template substr<1>();
2246 template <
typename T>
2247 constexpr auto normalize_accessor_name(
const T&)
2250 if constexpr (t.name.size > 3) {
2251 constexpr auto prefix = t.name.
template substr<0, 3>();
2252 constexpr bool cont_snake_or_camel = (t.name.size > 4 && t.name.data[3] ==
'_' && !is_upper(t.name.data[4])) || is_upper(t.name.data[3]);
2253 constexpr bool cont_pascal = is_upper(t.name.data[3]);
2255 if constexpr ((is_readable(T{}) && ((prefix ==
"Get" && cont_pascal) || (prefix ==
"get" && cont_snake_or_camel)))
2256 || (is_writable(T{}) && ((prefix ==
"Set" && cont_pascal) || (prefix ==
"set" && cont_snake_or_camel)))) {
2257 constexpr bool prefer_upper = is_upper(prefix.data[0]);
2258 return normalize_bare_accessor_name<T, prefer_upper>();
2269 template <
typename T>
2270 std::string get_display_name(
const T& t)
noexcept
2272 if constexpr (
trait::is_property_v<T>) {
2273 auto&& friendly_name =
util::get<
attr::
property>(t.attributes).friendly_name;
2274 return friendly_name ? *friendly_name : detail::normalize_accessor_name(t).str();
2276 return t.name.str();
2284 template <
typename T>
2287 static const std::string name(detail::get_display_name(t));
2288 return name.c_str();
2293 #ifndef REFL_DETAIL_FORCE_EBO
2295 #define REFL_DETAIL_FORCE_EBO __declspec(empty_bases)
2297 #define REFL_DETAIL_FORCE_EBO
2308 template <
typename T>
2309 struct get_member_info;
2311 template <
typename T, size_t N>
2314 using type =
typename refl_impl::metadata::type_info__<T>::
template member<N>;
2317 template <
typename T, size_t N>
2320 using type =
typename refl_impl::metadata::type_info__<T>::
template member<N>;
2323 template <
typename T,
typename U>
2324 constexpr T& static_ref_cast(U& value)
noexcept
2326 return static_cast<T&>(value);
2329 template <
typename T,
typename U>
2330 constexpr const T& static_ref_cast(
const U& value)
noexcept
2332 return static_cast<
const T&>(value);
2336 template <
typename Derived,
typename Func>
2337 struct REFL_DETAIL_FORCE_EBO function_proxy :
public get_member_info<Func>::type::
template remap<function_proxy<Derived, Func>>
2343 template <
typename Self,
typename... Args>
2344 static constexpr decltype(
auto) invoke_impl(Self&& self, Args&& ... args)
2346 return Derived::
template invoke_impl<Func>(static_ref_cast<Derived>(self), std::forward<Args>(args)...);
2351 template <
typename,
typename>
2355 template <
typename Derived,
typename... Members>
2361 template <
typename Derived,
typename Field>
2362 struct REFL_DETAIL_FORCE_EBO field_proxy :
public get_member_info<Field>::type::
template remap<field_proxy<Derived, Field>>
2368 template <
typename Self,
typename... Args>
2369 static constexpr decltype(
auto) invoke_impl(Self&& self, Args&& ... args)
2371 return Derived::
template invoke_impl<Field>(static_ref_cast<Derived>(self), std::forward<Args>(args)...);
2377 template <
typename,
typename>
2381 template <
typename Derived,
typename... Members>
2386 template <
typename T>
2389 template <
typename T>
2390 using fields =
trait::filter_t<
trait::
is_field, member_list<std::remove_reference_t<T>>>;
2412 template <
typename Derived,
typename Target>
2414 :
public detail::function_proxies<
proxy<Derived, Target>, detail::functions<Target>>
2415 ,
public detail::field_proxies<
proxy<Derived, Target>, detail::fields<Target>>
2418 sizeof(detail::function_proxies<
proxy<Derived, Target>, detail::functions<Target>>) == 1,
2419 "Multiple inheritance EBO did not kick in! "
2420 "You could try defining the REFL_DETAIL_FORCE_EBO macro appropriately to enable it on the required types. "
2421 "Default for MSC is `__declspec(empty_bases)`.");
2424 trait::is_reflectable_v<Target>,
2425 "Target type must be reflectable!");
2433 template <
typename P,
typename F>
2434 friend struct detail::function_proxy;
2436 template <
typename P,
typename F>
2437 friend struct detail::field_proxy;
2440 template <
typename Member,
typename Self,
typename... Args>
2441 static constexpr decltype(
auto) invoke_impl(Self&& self, Args&& ... args)
2443 return Derived::
template invoke_impl<Member>(detail::static_ref_cast<Derived>(self), std::forward<Args>(args)...);
2455 template <
typename T>
2459 template <
typename Derived,
typename Target>
2460 static std::true_type test(
runtime::
proxy<Derived, Target>*);
2461 static std::false_type test(...);
2463 static constexpr bool value{ !std::is_reference_v<T> &&
decltype(test(std::declval<remove_qualifiers_t<T>*>()))::value };
2466 template <
typename T>
2467 [[maybe_unused]]
static constexpr bool is_proxy_v{ is_proxy<T>::value };
2472 template <
typename T>
2473 void debug(std::ostream& os,
const T& value,
bool compact =
false);
2477 template <
typename T,
typename =
decltype(std::declval<std::ostream&>() << std::declval<T>())>
2478 std::true_type is_ostream_printable_test(
int);
2480 template <
typename T>
2481 std::false_type is_ostream_printable_test(...);
2483 template <
typename T>
2484 constexpr bool is_ostream_printable_v{
decltype(is_ostream_printable_test<T>(0))::value };
2486 int next_depth(
int depth)
2488 return depth == -1 || depth > 8
2493 void indent(std::ostream& os,
int depth)
2495 for (
int i = 0; i < depth; i++) {
2500 template <
typename T>
2501 void debug_impl(std::ostream& os,
const T& value, [[maybe_unused]]
int depth);
2503 template <
typename T>
2504 void debug_detailed(std::ostream& os,
const T& value,
int depth)
2506 using type_descriptor = type_descriptor<T>;
2507 bool compact = depth == -1;
2509 os << type_descriptor::name <<
" { ";
2510 if (!compact) os <<
'\n';
2512 constexpr auto readable_members = filter(type_descriptor::members, [](
auto member) {
return is_readable(member); });
2513 for_each(readable_members, [&](
auto member, [[maybe_unused]]
auto index) {
2514 int new_depth = next_depth(depth);
2516 indent(os, new_depth);
2517 os << get_display_name(member) <<
" = ";
2519 if constexpr (
trait::contains_instance_v<
attr::
debug,
typename decltype(member)::attribute_types>) {
2521 auto debug_attr =
util::get_instance<
attr::
debug>(member.attributes);
2522 debug_attr.write(os, value);
2525 debug_impl(os, member(value), new_depth);
2528 if (!compact || index + 1 != readable_members.size) {
2537 if (compact) os <<
' ';
2542 template <
typename T>
2543 void debug_reflectable(std::ostream& os,
const T& value,
int depth)
2545 using type_descriptor = type_descriptor<T>;
2546 if constexpr (
trait::contains_instance_v<
attr::
debug,
typename type_descriptor::attribute_types>) {
2548 auto debug_attr =
util::get_instance<
attr::
debug>(type_descriptor::attributes);
2549 debug_attr.write(os, value);
2551 else if constexpr (detail::is_ostream_printable_v<T>) {
2556 debug_detailed(os, value, depth);
2560 template <
typename T>
2561 void debug_container(std::ostream& os,
const T& value,
int depth)
2563 bool compact = depth == -1;
2566 auto end = value.end();
2567 for (
auto it = value.begin(); it != end; ++it)
2569 if (!compact) os <<
'\n';
2570 int new_depth = next_depth(depth);
2571 indent(os, new_depth);
2573 debug_impl(os, *it, new_depth);
2574 if (std::next(it, 1) != end) {
2577 else if (!compact) {
2586 template <
typename T>
2587 void debug_impl(std::ostream& os,
const T& value,
int depth)
2589 using no_pointer_t = std::remove_pointer_t<T>;
2591 if constexpr (std::is_same_v<
bool, T>) {
2592 os << (value ?
"true" :
"false");
2594 else if constexpr (std::is_pointer_v<T> && !std::is_void_v<no_pointer_t> &&
trait::is_reflectable_v<no_pointer_t>) {
2595 if (value ==
nullptr) {
2600 debug_impl(os, *value, -1);
2603 else if constexpr (
trait::is_reflectable_v<T>) {
2604 debug_reflectable(os, value, depth);
2606 else if constexpr (detail::is_ostream_printable_v<T>) {
2609 else if constexpr (
trait::is_container_v<T>) {
2610 debug_container(os, value, depth);
2613 os <<
"(not printable)";
2625 template <
typename T>
2628 static_assert(
trait::is_reflectable_v<T> ||
trait::is_container_v<T> || detail::is_ostream_printable_v<T>,
2629 "Type is not reflectable, not a container of reflectable types and does not support operator<<(std::ostream&, T)!");
2631 detail::debug_impl(os, value, compact ? -1 : 0);
2637 template <
typename... Ts>
2640 refl::
runtime::debug(os, std::forward_as_tuple(
static_cast<
const Ts&>(values)...),
true);
2648 template <
typename T>
2651 std::stringstream ss;
2652 debug(ss, value, compact);
2659 template <
typename... Ts>
2662 return refl::
runtime::debug_str(std::forward_as_tuple(
static_cast<
const Ts&>(values)...),
true);
2673 template <
typename U,
typename T,
typename... Args>
2674 U
invoke(T&& target,
const char* name, Args&&... args)
2676 using type = std::remove_reference_t<T>;
2677 static_assert(
refl::
trait::is_reflectable_v<type>,
"Unsupported type!");
2678 typedef type_descriptor<type> type_descriptor;
2680 std::optional<U> result;
2682 bool found{
false };
2683 for_each(type_descriptor::members, [&](
auto member) {
2684 using member_t =
decltype(member);
2687 if constexpr (std::is_invocable_r_v<U,
decltype(member), T, Args...>) {
2688 if constexpr (
trait::is_field_v<member_t>) {
2689 if (std::strcmp(member.name.c_str(), name) == 0) {
2690 result.emplace(member(target, std::forward<Args>(args)...));
2694 else if constexpr (
trait::is_function_v<member_t>) {
2695 if (std::strcmp(member.name.c_str(), name) == 0) {
2696 result.emplace(member(target, std::forward<Args>(args)...));
2704 return std::move(*result);
2707 throw std::runtime_error(std::string(
"The member ")
2708 + type_descriptor::name.str() +
"::" + name
2709 +
" is not compatible with the provided parameters or return type, is not reflected or does not exist!");
2717 namespace refl::detail
2719 constexpr bool validate_attr_unique(
type_list<>)
noexcept
2725 template <
typename T,
typename... Ts>
2726 constexpr bool validate_attr_unique(
type_list<T, Ts...>)
noexcept
2728 constexpr bool cond = (... && (!std::is_same_v<T, Ts> && validate_attr_unique(
type_list<Ts>{})));
2729 static_assert(cond,
"Some of the attributes provided have duplicate types!");
2733 template <
typename Req,
typename Attr>
2734 constexpr bool validate_attr_usage()
noexcept
2736 return std::is_base_of_v<Req, Attr>;
2744 template <
typename Req,
typename... Args>
2745 constexpr std::tuple<
trait::remove_qualifiers_t<Args>...> make_attributes(Args&&... args)
noexcept
2747 constexpr bool check_unique = validate_attr_unique(
type_list<Args...>{});
2748 static_assert(check_unique,
"Some of the supplied attributes cannot be used on this declaration!");
2750 constexpr bool check_usage = (... && validate_attr_usage<Req,
trait::remove_qualifiers_t<Args>>());
2751 static_assert(check_usage,
"Some of the supplied attributes cannot be used on this declaration!");
2753 return std::tuple<
trait::remove_qualifiers_t<Args>...>{ std::forward<Args>(args)... };
2756 template <
typename T,
typename...>
2766 template <
typename T,
typename... Ts>
2767 using head_t =
typename head<T, Ts...>::type;
2775 #define REFL_DETAIL_STR_IMPL(...) #__VA_ARGS__
2779 #define REFL_DETAIL_GROUP(...) __VA_ARGS__
2786 #define REFL_DETAIL_ATTRIBUTES(DeclType, ...)
2787 static constexpr auto attributes{ ::refl::detail::make_attributes<::refl::attr::usage:: DeclType>(__VA_ARGS__) };
2792 #define REFL_DETAIL_TYPE_BODY(TypeName, ...)
2796 static constexpr size_t member_index_offset = __COUNTER__ + 1
;
2797 template <size_t N, typename = void>
2811 #define REFL_TYPE(TypeName, ...)
2812 namespace refl_impl::metadata { template<> struct type_info__<TypeName> {
2828 #define REFL_TEMPLATE(TemplateDeclaration, TypeName, ...)
2842 static constexpr size_t member_count{ __COUNTER__ - member_index_offset };
2845 #define REFL_DETAIL_MEMBER_HEADER template<typename Unused__> struct member<__COUNTER__ - member_index_offset, Unused__>
2847 #define REFL_DETAIL_MEMBER_COMMON(MemberType_, MemberName_, ...)
2848 typedef ::refl::member::MemberType_ member_type;
2849 static constexpr auto name{ ::refl::util::make_const_string(REFL_DETAIL_STR(MemberName_)) };
2859 #define REFL_DETAIL_MEMBER_PROXY(MemberName_)
2860 template <typename Proxy> struct remap {
2861 template <typename... Args> decltype(auto) MemberName_(Args&&... args) {
2862 return Proxy::invoke_impl(static_cast<Proxy&>(*this), ::std::forward<Args>(args)...);
2864 template <typename... Args> decltype(auto) MemberName_(Args&&... args) const {
2865 return Proxy::invoke_impl(static_cast<const Proxy&>(*this), ::std::forward<Args>(args)...);
2872 #define REFL_FIELD(FieldName_, ...)
2873 REFL_DETAIL_MEMBER_HEADER
{
2874 REFL_DETAIL_MEMBER_COMMON
(field, FieldName_, __VA_ARGS__)
2876 typedef decltype(type::FieldName_) value_type;
2877 static constexpr auto pointer{ &type::FieldName_ };
2878 REFL_DETAIL_MEMBER_PROXY
(FieldName_);
2884 #define REFL_FUNC(FunctionName_, ...)
2885 REFL_DETAIL_MEMBER_HEADER
{
2886 REFL_DETAIL_MEMBER_COMMON
(function, FunctionName_, __VA_ARGS__)
2888 template<typename Self, typename... Args> static constexpr auto invoke(Self&& self, Args&&... args) -> decltype(std::declval<Self>().FunctionName_(::std::declval<Args>()...)) {
2889 return ::std::forward<Self>(self).FunctionName_(::std::forward<Args>(args)...);
2891 template<typename... Args> static constexpr auto invoke(Args&&... args) -> decltype(::refl::detail::head_t<type, Args...>::FunctionName_(::std::declval<Args>()...)) {
2892 return ::refl::detail::head_t<type, Args...>::FunctionName_(::std::forward<Args>(args)...);
2894 template <typename Dummy = void>
2895 static constexpr auto pointer() -> decltype(&::refl::detail::head_t<type, Dummy>::FunctionName_) { return &::refl::detail::head_t<type, Dummy>::FunctionName_; }
2896 REFL_DETAIL_MEMBER_PROXY
(FunctionName_);
2903 #define REFL_DETAIL_PRIMITIVE(TypeName)
2908 REFL_DETAIL_PRIMITIVE(
char);
2909 REFL_DETAIL_PRIMITIVE(
wchar_t);
2910 REFL_DETAIL_PRIMITIVE(
char16_t);
2911 REFL_DETAIL_PRIMITIVE(
char32_t);
2912 #ifdef __cpp_lib_char8_t
2913 REFL_DETAIL_PRIMITIVE(char8_t);
2917 REFL_DETAIL_PRIMITIVE(
bool);
2918 REFL_DETAIL_PRIMITIVE(
signed char);
2919 REFL_DETAIL_PRIMITIVE(
unsigned char);
2920 REFL_DETAIL_PRIMITIVE(
signed short);
2921 REFL_DETAIL_PRIMITIVE(
unsigned short);
2922 REFL_DETAIL_PRIMITIVE(
signed int);
2923 REFL_DETAIL_PRIMITIVE(
unsigned int);
2924 REFL_DETAIL_PRIMITIVE(
signed long);
2925 REFL_DETAIL_PRIMITIVE(
unsigned long);
2926 REFL_DETAIL_PRIMITIVE(
signed long long);
2927 REFL_DETAIL_PRIMITIVE(
unsigned long long);
2930 REFL_DETAIL_PRIMITIVE(
float);
2931 REFL_DETAIL_PRIMITIVE(
double);
2932 REFL_DETAIL_PRIMITIVE(
long double);
2935 REFL_DETAIL_PRIMITIVE(
decltype(nullptr));
2941 #undef REFL_DETAIL_PRIMITIVE
2943 #define REFL_DETAIL_POINTER(Ptr)
2944 template<typename T>
2945 struct type_info__<T Ptr> {
2949 static constexpr auto name{ ::refl::util::make_const_string(#Ptr) };
2950 static constexpr ::std::tuple<> attributes{ };
2951 static constexpr size_t member_count{ 0
};
2958 REFL_DETAIL_POINTER(*);
2959 REFL_DETAIL_POINTER(&);
2960 REFL_DETAIL_POINTER(&&);
2964 #undef REFL_DETAIL_POINTER
2966 namespace refl::detail
2968 template <
typename T>
2969 auto write_impl(std::ostream& os, T&& t) ->
decltype((os << t),
void())
2974 template <
typename T>
2975 void write_impl(std::ostream& os,
const volatile T* ptr)
2978 os <<
"(" << reflect<T>().name <<
"*)" << std::hex << ptr;
2982 inline void write_impl(std::ostream& os,
const char* ptr)
2987 inline void write_impl(std::ostream& os,
const std::exception& e)
2990 #ifdef REFL_RTTI_ENABLED
2991 os <<
" (" <<
typeid(e).name() <<
")";
2993 os <<
": `" << e.what() <<
"`";
2996 inline void write_impl(std::ostream& os,
const std::string& t)
2998 os << std::quoted(t);
3001 inline void write_impl(std::ostream& os,
const std::wstring& t)
3005 #pragma warning(push)
3006 #pragma warning(disable:4996
)
3008 std::mbstate_t state = std::mbstate_t();
3009 const wchar_t* wsptr = t.c_str();
3010 std::size_t len = 1 + std::wcsrtombs(
nullptr, &wsptr, 0, &state);
3012 std::string mbstr(len,
'\0');
3013 std::wcsrtombs(mbstr.data(), &wsptr, mbstr.size(), &state);
3015 os << std::quoted(mbstr);
3017 #pragma warning(pop)
3021 template <
typename Tuple, size_t... Idx>
3022 void write_impl(std::ostream& os, Tuple&& t, std::index_sequence<Idx...>)
3025 refl::
util::ignore((os << std::get<Idx>(t))...);
3029 template <
typename... Ts>
3030 void write_impl(std::ostream& os,
const std::tuple<Ts...>& t)
3032 write_impl(os, t, std::make_index_sequence<
sizeof...(Ts)>{});
3035 template <
typename K,
typename V>
3036 void write_impl(std::ostream& os,
const std::pair<K, V>& t);
3038 template <
typename K,
typename V>
3039 void write_impl(std::ostream& os,
const std::pair<K, V>& t)
3044 write(os, t.second);
3048 template <
typename T,
typename D>
3049 void write_impl(std::ostream& os,
const std::unique_ptr<T, D>& t)
3051 runtime::debug(os, t.get(),
true);
3054 template <
typename T>
3055 void write_impl(std::ostream& os,
const std::shared_ptr<T>& t)
3057 runtime::debug(os, t.get(),
true);
3060 template <
typename T>
3061 void write_impl(std::ostream& os,
const std::weak_ptr<T>& t)
3063 runtime::debug(os, t.lock().get(),
true);
3067 constexpr auto write = [](std::ostream & os,
auto&& t) ->
void
3076 #ifndef REFL_NO_STD_SUPPORT
3088 (
typename Elem,
typename Traits,
typename Alloc),
3095 #ifdef __cpp_lib_string_view
3098 (
typename Elem,
typename Traits),
3114 (
typename T,
typename D),
3126 (
typename K,
typename V),
3133 #ifndef REFL_NO_AUTO_MACRO
3135 #define REFL_DETAIL_EXPAND(x) x
3136 #define REFL_DETAIL_FOR_EACH_0(...)
3137 #define REFL_DETAIL_FOR_EACH_1(what, x, ...) what(x)
3138 #define REFL_DETAIL_FOR_EACH_2(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_1
(what, __VA_ARGS__))
3139 #define REFL_DETAIL_FOR_EACH_3(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_2
(what, __VA_ARGS__))
3140 #define REFL_DETAIL_FOR_EACH_4(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_3
(what, __VA_ARGS__))
3141 #define REFL_DETAIL_FOR_EACH_5(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_4
(what, __VA_ARGS__))
3142 #define REFL_DETAIL_FOR_EACH_6(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_5
(what, __VA_ARGS__))
3143 #define REFL_DETAIL_FOR_EACH_7(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_6
(what, __VA_ARGS__))
3144 #define REFL_DETAIL_FOR_EACH_8(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_7
(what, __VA_ARGS__))
3145 #define REFL_DETAIL_FOR_EACH_9(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_8
(what, __VA_ARGS__))
3146 #define REFL_DETAIL_FOR_EACH_10(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_9
(what, __VA_ARGS__))
3147 #define REFL_DETAIL_FOR_EACH_11(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_10
(what, __VA_ARGS__))
3148 #define REFL_DETAIL_FOR_EACH_12(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_11
(what, __VA_ARGS__))
3149 #define REFL_DETAIL_FOR_EACH_13(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_12
(what, __VA_ARGS__))
3150 #define REFL_DETAIL_FOR_EACH_14(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_13
(what, __VA_ARGS__))
3151 #define REFL_DETAIL_FOR_EACH_15(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_14
(what, __VA_ARGS__))
3152 #define REFL_DETAIL_FOR_EACH_16(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_15
(what, __VA_ARGS__))
3153 #define REFL_DETAIL_FOR_EACH_17(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_16
(what, __VA_ARGS__))
3154 #define REFL_DETAIL_FOR_EACH_18(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_17
(what, __VA_ARGS__))
3155 #define REFL_DETAIL_FOR_EACH_19(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_18
(what, __VA_ARGS__))
3156 #define REFL_DETAIL_FOR_EACH_20(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_19
(what, __VA_ARGS__))
3157 #define REFL_DETAIL_FOR_EACH_21(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_20
(what, __VA_ARGS__))
3158 #define REFL_DETAIL_FOR_EACH_22(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_21
(what, __VA_ARGS__))
3159 #define REFL_DETAIL_FOR_EACH_23(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_22
(what, __VA_ARGS__))
3160 #define REFL_DETAIL_FOR_EACH_24(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_23
(what, __VA_ARGS__))
3161 #define REFL_DETAIL_FOR_EACH_25(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_24
(what, __VA_ARGS__))
3162 #define REFL_DETAIL_FOR_EACH_26(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_25
(what, __VA_ARGS__))
3163 #define REFL_DETAIL_FOR_EACH_27(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_26
(what, __VA_ARGS__))
3164 #define REFL_DETAIL_FOR_EACH_28(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_27
(what, __VA_ARGS__))
3165 #define REFL_DETAIL_FOR_EACH_29(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_28
(what, __VA_ARGS__))
3166 #define REFL_DETAIL_FOR_EACH_30(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_29
(what, __VA_ARGS__))
3167 #define REFL_DETAIL_FOR_EACH_31(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_30
(what, __VA_ARGS__))
3168 #define REFL_DETAIL_FOR_EACH_32(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_31
(what, __VA_ARGS__))
3169 #define REFL_DETAIL_FOR_EACH_33(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_32
(what, __VA_ARGS__))
3170 #define REFL_DETAIL_FOR_EACH_34(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_33
(what, __VA_ARGS__))
3171 #define REFL_DETAIL_FOR_EACH_35(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_34
(what, __VA_ARGS__))
3172 #define REFL_DETAIL_FOR_EACH_36(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_35
(what, __VA_ARGS__))
3173 #define REFL_DETAIL_FOR_EACH_37(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_36
(what, __VA_ARGS__))
3174 #define REFL_DETAIL_FOR_EACH_38(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_37
(what, __VA_ARGS__))
3175 #define REFL_DETAIL_FOR_EACH_39(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_38
(what, __VA_ARGS__))
3176 #define REFL_DETAIL_FOR_EACH_40(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_39
(what, __VA_ARGS__))
3177 #define REFL_DETAIL_FOR_EACH_41(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_40
(what, __VA_ARGS__))
3178 #define REFL_DETAIL_FOR_EACH_42(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_41
(what, __VA_ARGS__))
3179 #define REFL_DETAIL_FOR_EACH_43(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_42
(what, __VA_ARGS__))
3180 #define REFL_DETAIL_FOR_EACH_44(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_43
(what, __VA_ARGS__))
3181 #define REFL_DETAIL_FOR_EACH_45(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_44
(what, __VA_ARGS__))
3182 #define REFL_DETAIL_FOR_EACH_46(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_45
(what, __VA_ARGS__))
3183 #define REFL_DETAIL_FOR_EACH_47(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_46
(what, __VA_ARGS__))
3184 #define REFL_DETAIL_FOR_EACH_48(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_47
(what, __VA_ARGS__))
3185 #define REFL_DETAIL_FOR_EACH_49(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_48
(what, __VA_ARGS__))
3186 #define REFL_DETAIL_FOR_EACH_50(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_49
(what, __VA_ARGS__))
3187 #define REFL_DETAIL_FOR_EACH_51(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_50
(what, __VA_ARGS__))
3188 #define REFL_DETAIL_FOR_EACH_52(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_51
(what, __VA_ARGS__))
3189 #define REFL_DETAIL_FOR_EACH_53(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_52
(what, __VA_ARGS__))
3190 #define REFL_DETAIL_FOR_EACH_54(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_53
(what, __VA_ARGS__))
3191 #define REFL_DETAIL_FOR_EACH_55(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_54
(what, __VA_ARGS__))
3192 #define REFL_DETAIL_FOR_EACH_56(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_55
(what, __VA_ARGS__))
3193 #define REFL_DETAIL_FOR_EACH_57(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_56
(what, __VA_ARGS__))
3194 #define REFL_DETAIL_FOR_EACH_58(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_57
(what, __VA_ARGS__))
3195 #define REFL_DETAIL_FOR_EACH_59(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_58
(what, __VA_ARGS__))
3196 #define REFL_DETAIL_FOR_EACH_60(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_59
(what, __VA_ARGS__))
3197 #define REFL_DETAIL_FOR_EACH_61(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_60
(what, __VA_ARGS__))
3198 #define REFL_DETAIL_FOR_EACH_62(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_61
(what, __VA_ARGS__))
3199 #define REFL_DETAIL_FOR_EACH_63(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_62
(what, __VA_ARGS__))
3200 #define REFL_DETAIL_FOR_EACH_64(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_63
(what, __VA_ARGS__))
3201 #define REFL_DETAIL_FOR_EACH_65(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_64
(what, __VA_ARGS__))
3202 #define REFL_DETAIL_FOR_EACH_66(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_65
(what, __VA_ARGS__))
3203 #define REFL_DETAIL_FOR_EACH_67(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_66
(what, __VA_ARGS__))
3204 #define REFL_DETAIL_FOR_EACH_68(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_67
(what, __VA_ARGS__))
3205 #define REFL_DETAIL_FOR_EACH_69(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_68
(what, __VA_ARGS__))
3206 #define REFL_DETAIL_FOR_EACH_70(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_69
(what, __VA_ARGS__))
3207 #define REFL_DETAIL_FOR_EACH_71(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_70
(what, __VA_ARGS__))
3208 #define REFL_DETAIL_FOR_EACH_72(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_71
(what, __VA_ARGS__))
3209 #define REFL_DETAIL_FOR_EACH_73(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_72
(what, __VA_ARGS__))
3210 #define REFL_DETAIL_FOR_EACH_74(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_73
(what, __VA_ARGS__))
3211 #define REFL_DETAIL_FOR_EACH_75(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_74
(what, __VA_ARGS__))
3212 #define REFL_DETAIL_FOR_EACH_76(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_75
(what, __VA_ARGS__))
3213 #define REFL_DETAIL_FOR_EACH_77(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_76
(what, __VA_ARGS__))
3214 #define REFL_DETAIL_FOR_EACH_78(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_77
(what, __VA_ARGS__))
3215 #define REFL_DETAIL_FOR_EACH_79(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_78
(what, __VA_ARGS__))
3216 #define REFL_DETAIL_FOR_EACH_80(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_79
(what, __VA_ARGS__))
3217 #define REFL_DETAIL_FOR_EACH_81(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_80
(what, __VA_ARGS__))
3218 #define REFL_DETAIL_FOR_EACH_82(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_81
(what, __VA_ARGS__))
3219 #define REFL_DETAIL_FOR_EACH_83(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_82
(what, __VA_ARGS__))
3220 #define REFL_DETAIL_FOR_EACH_84(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_83
(what, __VA_ARGS__))
3221 #define REFL_DETAIL_FOR_EACH_85(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_84
(what, __VA_ARGS__))
3222 #define REFL_DETAIL_FOR_EACH_86(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_85
(what, __VA_ARGS__))
3223 #define REFL_DETAIL_FOR_EACH_87(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_86
(what, __VA_ARGS__))
3224 #define REFL_DETAIL_FOR_EACH_88(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_87
(what, __VA_ARGS__))
3225 #define REFL_DETAIL_FOR_EACH_89(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_88
(what, __VA_ARGS__))
3226 #define REFL_DETAIL_FOR_EACH_90(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_89
(what, __VA_ARGS__))
3227 #define REFL_DETAIL_FOR_EACH_91(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_90
(what, __VA_ARGS__))
3228 #define REFL_DETAIL_FOR_EACH_92(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_91
(what, __VA_ARGS__))
3229 #define REFL_DETAIL_FOR_EACH_93(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_92
(what, __VA_ARGS__))
3230 #define REFL_DETAIL_FOR_EACH_94(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_93
(what, __VA_ARGS__))
3231 #define REFL_DETAIL_FOR_EACH_95(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_94
(what, __VA_ARGS__))
3232 #define REFL_DETAIL_FOR_EACH_96(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_95
(what, __VA_ARGS__))
3233 #define REFL_DETAIL_FOR_EACH_97(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_96
(what, __VA_ARGS__))
3234 #define REFL_DETAIL_FOR_EACH_98(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_97
(what, __VA_ARGS__))
3235 #define REFL_DETAIL_FOR_EACH_99(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_98
(what, __VA_ARGS__))
3236 #define REFL_DETAIL_FOR_EACH_100(what, x, ...) what(x) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_99
(what, __VA_ARGS__))
3238 #define REFL_DETAIL_FOR_EACH_NARG(...) REFL_DETAIL_FOR_EACH_NARG_
(__VA_ARGS__, REFL_DETAIL_FOR_EACH_RSEQ_N
())
3239 #define REFL_DETAIL_FOR_EACH_NARG_(...) REFL_DETAIL_EXPAND
(REFL_DETAIL_FOR_EACH_ARG_N
(__VA_ARGS__))
3240 #define REFL_DETAIL_FOR_EACH_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, _77, _78, _79, _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, _93, _94, _95, _96, _97, _98, _99, _100, N, ...) N
3241 #define REFL_DETAIL_FOR_EACH_RSEQ_N() 100
, 99
, 98
, 97
, 96
, 95
, 94
, 93
, 92
, 91
, 90
, 89
, 88
, 87
, 86
, 85
, 84
, 83
, 82
, 81
, 80
, 79
, 78
, 77
, 76
, 75
, 74
, 73
, 72
, 71
, 70
, 69
, 68
, 67
, 66
, 65
, 64
, 63
, 62
, 61
, 60
, 59
, 58
, 57
, 56
, 55
, 54
, 53
, 52
, 51
, 50
, 49
, 48
, 47
, 46
, 45
, 44
, 43
, 42
, 41
, 40
, 39
, 38
, 37
, 36
, 35
, 34
, 33
, 32
, 31
, 30
, 29
, 28
, 27
, 26
, 25
, 24
, 23
, 22
, 21
, 20
, 19
, 18
, 17
, 16
, 15
, 14
, 13
, 12
, 11
, 10
, 9
, 8
, 7
, 6
, 5
, 4
, 3
, 2
, 1
, 0
3242 #define REFL_DETAIL_CONCATENATE(x, y) x##y
3243 #define REFL_DETAIL_FOR_EACH_(N, what, ...) REFL_DETAIL_EXPAND
(REFL_DETAIL_CONCATENATE
(REFL_DETAIL_FOR_EACH_
, N)(what, __VA_ARGS__))
3244 #define REFL_DETAIL_FOR_EACH(what, ...) REFL_DETAIL_FOR_EACH_
(REFL_DETAIL_FOR_EACH_NARG
(__VA_ARGS__), what, __VA_ARGS__)
3249 #ifdef __INTELLISENSE__
3251 #define REFL_DETAIL_EX_1_type(X, ...) REFL_TYPE(X)
3252 #define REFL_DETAIL_EX_1_template(X, Y, ...) REFL_TEMPLATE(X, Y)
3253 #define REFL_DETAIL_EX_1_field(X, ...) REFL_FIELD(X)
3254 #define REFL_DETAIL_EX_1_func(X, ...) REFL_FUNC(X)
3258 #define REFL_DETAIL_EX_1_type(...) REFL_DETAIL_EX_EXPAND
(REFL_DETAIL_EX_DEFER
(REFL_TYPE)(__VA_ARGS__))
3259 #define REFL_DETAIL_EX_1_template(...) REFL_DETAIL_EX_EXPAND
(REFL_DETAIL_EX_DEFER
(REFL_TEMPLATE)(__VA_ARGS__))
3260 #define REFL_DETAIL_EX_1_field(...) REFL_DETAIL_EX_EXPAND
(REFL_DETAIL_EX_DEFER
(REFL_FIELD
)(__VA_ARGS__))
3261 #define REFL_DETAIL_EX_1_func(...) REFL_DETAIL_EX_EXPAND
(REFL_DETAIL_EX_DEFER
(REFL_FUNC
)(__VA_ARGS__))
3265 #define REFL_DETAIL_EX_(Specifier, ...) REFL_DETAIL_EX_1_##Specifier __VA_ARGS__
3267 #define REFL_DETAIL_EX_EMPTY()
3268 #define REFL_DETAIL_EX_DEFER(Id) Id REFL_DETAIL_EX_EMPTY
()
3269 #define REFL_DETAIL_EX_EXPAND(...) __VA_ARGS__
3271 #define REFL_DETAIL_EX_END() REFL_END
3273 #define REFL_AUTO(...) REFL_DETAIL_FOR_EACH
(REFL_DETAIL_EX_
, __VA_ARGS__) REFL_DETAIL_EX_EXPAND
(REFL_DETAIL_EX_DEFER
(REFL_DETAIL_EX_END
)())