use adl function

iguana/ylt/reflection/member_names.hpp

@@ -64,28 +64,50 @@ struct member_tratis<T Owner::*> {
 };
 
 template <typename T, typename = void>
-struct has_alias_field_names_t : std::false_type {};
+struct has_alias_struct_name_t : std::false_type {};
 
 template <typename T>
-struct has_alias_field_names_t<
-    T, std::void_t<decltype(ylt_alias_struct<T>::get_alias_field_names())>>
+struct has_alias_struct_name_t<
+    T, std::void_t<decltype(get_alias_struct_name((T*)nullptr))>>
+    : std::true_type {};
+
+template <typename T, typename = void>
+struct has_inner_alias_struct_name_t : std::false_type {};
+
+template <typename T>
+struct has_inner_alias_struct_name_t<
+    T, std::void_t<decltype(T::get_alias_struct_name((T*)nullptr))>>
     : std::true_type {};
 
 template <typename T>
-inline constexpr bool has_alias_field_names_v =
-    has_alias_field_names_t<T>::value;
+constexpr bool has_alias_struct_name_v = has_alias_struct_name_t<T>::value;
+
+template <typename T>
+constexpr bool has_inner_alias_struct_name_v =
+    has_inner_alias_struct_name_t<T>::value;
+
+template <typename T, typename = void>
+struct has_alias_field_names_t : std::false_type {};
+
+template <typename T>
+struct has_alias_field_names_t<
+    T, std::void_t<decltype(get_alias_field_names((T*)nullptr))>>
+    : std::true_type {};
 
 template <typename T, typename = void>
-struct has_alias_struct_names_t : std::false_type {};
+struct has_inner_alias_field_names_t : std::false_type {};
 
 template <typename T>
-struct has_alias_struct_names_t<
-    T, std::void_t<decltype(ylt_alias_struct<T>::get_alias_struct_name())>>
+struct has_inner_alias_field_names_t<
+    T, std::void_t<decltype(T::get_alias_field_names((T*)nullptr))>>
     : std::true_type {};
 
 template <typename T>
-inline constexpr bool has_alias_struct_name_v =
-    has_alias_struct_names_t<T>::value;
+constexpr bool has_alias_field_names_v = has_alias_field_names_t<T>::value;
+
+template <typename T>
+constexpr bool has_inner_alias_field_names_v =
+    has_inner_alias_field_names_t<T>::value;
 
 template <typename T, typename U, size_t... Is>
 inline constexpr void init_arr_with_tuple(U& arr, std::index_sequence<Is...>) {
@@ -217,7 +239,10 @@ struct field_alias_t {
 template <typename T>
 inline constexpr auto get_alias_field_names() {
   if constexpr (internal::has_alias_field_names_v<T>) {
-    return ylt_alias_struct<T>::get_alias_field_names();
+    return get_alias_field_names((T*)nullptr);
+  }
+  else if constexpr (internal::has_inner_alias_field_names_v<T>) {
+    return T::get_alias_field_names((T*)nullptr);
   }
   else {
     return std::array<std::string_view, 0>{};
@@ -227,7 +252,10 @@ inline constexpr auto get_alias_field_names() {
 template <typename T>
 constexpr std::string_view get_struct_name() {
   if constexpr (internal::has_alias_struct_name_v<T>) {
-    return ylt_alias_struct<T>::get_alias_struct_name();
+    return get_alias_struct_name((T*)nullptr);
+  }
+  else if constexpr (internal::has_inner_alias_struct_name_v<T>) {
+    return T::get_alias_struct_name((T*)nullptr);
   }
   else {
     return type_string<T>();
@@ -239,7 +267,8 @@ inline constexpr std::array<std::string_view, members_count_v<T>>
 get_member_names() {
   auto arr = internal::get_member_names<T>();
   using U = ylt::reflection::remove_cvref_t<T>;
-  if constexpr (internal::has_alias_field_names_v<U>) {
+  if constexpr (internal::has_alias_field_names_v<U> ||
+                internal::has_inner_alias_field_names_v<U>) {
     constexpr auto alias_arr = get_alias_field_names<U>();
     for (size_t i = 0; i < alias_arr.size(); i++) {
       arr[alias_arr[i].index] = alias_arr[i].alias_name;

test/test_cpp20.cpp

@@ -15,17 +15,16 @@ YLT_REFL(point_t, x, y);
 struct point_t1 {
   int x;
   int y;
-};
-YLT_REFL(point_t1, x, y);
-
-template <>
-struct ylt::reflection::ylt_alias_struct<point_t1> {
-  static constexpr std::string_view get_alias_struct_name() { return "point"; }
 
-  static constexpr auto get_alias_field_names() {
+  static constexpr auto get_alias_field_names(point_t1*) {
     return std::array{field_alias_t{"X", 0}, field_alias_t{"Y", 1}};
   }
+  static constexpr std::string_view get_alias_struct_name(point_t1*) {
+    return "point";
+  }
 };
+YLT_REFL(point_t1, x, y);
+
 struct test_variant {
   test_variant() = default;
   test_variant(int a, std::variant<double, std::string, int> b, double c)

test/test_xml.cpp

@@ -734,14 +734,14 @@ struct next_obj_t {
 };
 YLT_REFL(next_obj_t, x, y);
 
-template <>
-struct ylt::reflection::ylt_alias_struct<next_obj_t> {
-  static constexpr std::string_view get_alias_struct_name() { return "next"; }
+inline constexpr std::string_view get_alias_struct_name(next_obj_t *) {
+  return "next";
+}
 
-  static constexpr auto get_alias_field_names() {
-    return std::array{field_alias_t{"w", 0}, field_alias_t{"h", 1}};
-  }
-};
+inline constexpr auto get_alias_field_names(next_obj_t *) {
+  return std::array{ylt::reflection::field_alias_t{"w", 0},
+                    ylt::reflection::field_alias_t{"h", 1}};
+}
 
 struct out_object {
   std::unique_ptr<int> id;
@@ -750,14 +750,14 @@ struct out_object {
   YLT_REFL(out_object, id, name, obj);
 };
 
-template <>
-struct ylt::reflection::ylt_alias_struct<out_object> {
-  static constexpr std::string_view get_alias_struct_name() { return "qi"; }
+inline constexpr std::string_view get_alias_struct_name(out_object *) {
+  return "qi";
+}
 
-  static constexpr auto get_alias_field_names() {
-    return std::array{field_alias_t{"w", 0}, field_alias_t{"h", 1}};
-  }
-};
+inline constexpr auto get_alias_field_names(out_object *) {
+  return std::array{ylt::reflection::field_alias_t{"w", 0},
+                    ylt::reflection::field_alias_t{"h", 1}};
+}
 
 TEST_CASE("test alias") {
   out_object m{std::make_unique<int>(20), "tom", {21, 42}};