From 8eefddf19e055bc8fe2c78a492eb3ea73268f540 Mon Sep 17 00:00:00 2001
From: qicosmos <qicosmos@linux.alibaba.com>
Date: Mon, 15 Jul 2024 20:32:39 +0800
Subject: [PATCH] format

---
 include/ylt/reflection/member_count.hpp | 138 ++++++++++++------------
 1 file changed, 69 insertions(+), 69 deletions(-)

diff --git a/include/ylt/reflection/member_count.hpp b/include/ylt/reflection/member_count.hpp
index 6056676a4..8c91ea6b4 100644
--- a/include/ylt/reflection/member_count.hpp
+++ b/include/ylt/reflection/member_count.hpp
@@ -64,10 +64,10 @@ constexpr bool optional = !expected<T> && optional_impl<T>::value;
 
 namespace internal {
 #if __cpp_concepts >= 201907L
-  template <typename Type>
-  concept tuple_size = requires(Type tuple) {
-    std::tuple_size<remove_cvref_t<Type>>::value;
-  };
+template <typename Type>
+concept tuple_size = requires(Type tuple) {
+  std::tuple_size<remove_cvref_t<Type>>::value;
+};
 #else
 template <typename T, typename = void>
 struct tuple_size_impl : std::false_type {};
@@ -81,81 +81,81 @@ template <typename T>
 constexpr bool tuple_size = tuple_size_impl<T>::value;
 #endif
 
-  template <typename T, uint64_t version = 0>
-  struct compatible;
+template <typename T, uint64_t version = 0>
+struct compatible;
 
-  template <typename Type>
-  constexpr inline bool is_compatible_v = false;
+template <typename Type>
+constexpr inline bool is_compatible_v = false;
 
-  template <typename Type, uint64_t version>
-  constexpr inline bool is_compatible_v<compatible<Type, version>> = true;
+template <typename Type, uint64_t version>
+constexpr inline bool is_compatible_v<compatible<Type, version>> = true;
 
-  struct UniversalVectorType {
-    template <typename T>
-    operator std::vector<T>();
-  };
+struct UniversalVectorType {
+  template <typename T>
+  operator std::vector<T>();
+};
 
-  struct UniversalType {
-    template <typename T>
-    operator T();
-  };
+struct UniversalType {
+  template <typename T>
+  operator T();
+};
 
-  struct UniversalIntegralType {
-    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
-    operator T();
-  };
+struct UniversalIntegralType {
+  template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+  operator T();
+};
 
-  struct UniversalNullptrType {
-    operator std::nullptr_t();
-  };
+struct UniversalNullptrType {
+  operator std::nullptr_t();
+};
 
-  struct UniversalOptionalType {
-    template <typename U, typename = std::enable_if_t<optional<U>>>
-    operator U();
-  };
+struct UniversalOptionalType {
+  template <typename U, typename = std::enable_if_t<optional<U>>>
+  operator U();
+};
 
-  struct UniversalCompatibleType {
-    template <typename U, typename = std::enable_if_t<is_compatible_v<U>>>
-    operator U();
-  };
+struct UniversalCompatibleType {
+  template <typename U, typename = std::enable_if_t<is_compatible_v<U>>>
+  operator U();
+};
+
+template <typename T, typename construct_param_t, typename = void,
+          typename... Args>
+struct is_constructable_impl : std::false_type {};
+template <typename T, typename construct_param_t, typename... Args>
+struct is_constructable_impl<
+    T, construct_param_t,
+    std::void_t<decltype(T{{Args{}}..., {construct_param_t{}}})>, Args...>
+    : std::true_type {};
 
-  template <typename T, typename construct_param_t, typename = void,
-            typename... Args>
-  struct is_constructable_impl : std::false_type {};
-  template <typename T, typename construct_param_t, typename... Args>
-  struct is_constructable_impl<
-      T, construct_param_t,
-      std::void_t<decltype(T{{Args{}}..., {construct_param_t{}}})>, Args...>
-      : std::true_type {};
-
-  template <typename T, typename construct_param_t, typename... Args>
-  constexpr bool is_constructable =
-      is_constructable_impl<T, construct_param_t, void, Args...>::value;
-
-  template <typename T, typename... Args>
-  inline constexpr std::size_t members_count_impl() {
-    if constexpr (is_constructable<T, UniversalVectorType, Args...>) {
-      return members_count_impl<T, Args..., UniversalVectorType>();
-    }
-    else if constexpr (is_constructable<T, UniversalType, Args...>) {
-      return members_count_impl<T, Args..., UniversalType>();
-    }
-    else if constexpr (is_constructable<T, UniversalOptionalType, Args...>) {
-      return members_count_impl<T, Args..., UniversalOptionalType>();
-    }
-    else if constexpr (is_constructable<T, UniversalIntegralType, Args...>) {
-      return members_count_impl<T, Args..., UniversalIntegralType>();
-    }
-    else if constexpr (is_constructable<T, UniversalNullptrType, Args...>) {
-      return members_count_impl<T, Args..., UniversalNullptrType>();
-    }
-    else if constexpr (is_constructable<T, UniversalCompatibleType, Args...>) {
-      return members_count_impl<T, Args..., UniversalCompatibleType>();
-    }
-    else {
-      return sizeof...(Args);
-    }
+template <typename T, typename construct_param_t, typename... Args>
+constexpr bool is_constructable =
+    is_constructable_impl<T, construct_param_t, void, Args...>::value;
+
+template <typename T, typename... Args>
+inline constexpr std::size_t members_count_impl() {
+  if constexpr (is_constructable<T, UniversalVectorType, Args...>) {
+    return members_count_impl<T, Args..., UniversalVectorType>();
+  }
+  else if constexpr (is_constructable<T, UniversalType, Args...>) {
+    return members_count_impl<T, Args..., UniversalType>();
+  }
+  else if constexpr (is_constructable<T, UniversalOptionalType, Args...>) {
+    return members_count_impl<T, Args..., UniversalOptionalType>();
   }
+  else if constexpr (is_constructable<T, UniversalIntegralType, Args...>) {
+    return members_count_impl<T, Args..., UniversalIntegralType>();
+  }
+  else if constexpr (is_constructable<T, UniversalNullptrType, Args...>) {
+    return members_count_impl<T, Args..., UniversalNullptrType>();
+  }
+  else if constexpr (is_constructable<T, UniversalCompatibleType, Args...>) {
+    return members_count_impl<T, Args..., UniversalCompatibleType>();
+  }
+  else {
+    return sizeof...(Args);
+  }
+}
 }  // namespace internal
 
 template <typename T>