stl: std::true_type/std::false_type

src/entt/container/dense_map.hpp

@@ -1016,7 +1016,7 @@ namespace std {
 
 template<typename Key, typename Value, typename Allocator>
 struct uses_allocator<entt::internal::dense_map_node<Key, Value>, Allocator>
-    : std::true_type {};
+    : entt::stl::true_type {};
 
 } // namespace std
 /*! @endcond */

src/entt/core/any.hpp

@@ -48,7 +48,7 @@ template<typename Type, std::size_t Len, std::size_t Align>
 struct in_situ: std::bool_constant<(Len != 0u) && alignof(Type) <= Align && sizeof(Type) <= Len && std::is_nothrow_move_constructible_v<Type>> {};
 
 template<std::size_t Len, std::size_t Align>
-struct in_situ<void, Len, Align>: std::false_type {};
+struct in_situ<void, Len, Align>: stl::false_type {};
 
 } // namespace internal
 /*! @endcond */

src/entt/core/enum.hpp

@@ -11,7 +11,7 @@ namespace entt {
  * @tparam Type The enum type for which to enable bitmask support.
  */
 template<typename Type>
-struct enum_as_bitmask: std::false_type {};
+struct enum_as_bitmask: stl::false_type {};
 
 /*! @copydoc enum_as_bitmask */
 template<typename Type>
@@ -19,7 +19,7 @@ requires requires {
     requires std::is_enum_v<Type>;
     { Type::_entt_enum_as_bitmask } -> std::same_as<Type>;
 }
-struct enum_as_bitmask<Type>: std::true_type {};
+struct enum_as_bitmask<Type>: stl::true_type {};
 
 /**
  * @brief Helper variable template.

src/entt/core/tuple.hpp

@@ -13,14 +13,14 @@ namespace entt {
  * @tparam Type The type to test.
  */
 template<typename Type>
-struct is_tuple: std::false_type {};
+struct is_tuple: stl::false_type {};
 
 /**
  * @copybrief is_tuple
  * @tparam Args Tuple template arguments.
  */
 template<typename... Args>
-struct is_tuple<stl::tuple<Args...>>: std::true_type {};
+struct is_tuple<stl::tuple<Args...>>: stl::true_type {};
 
 /**
  * @brief Helper variable template.

src/entt/core/type_traits.hpp

@@ -579,7 +579,7 @@ using value_list_diff_t = value_list_diff<List...>::type;
 
 /*! @brief Same as std::is_invocable, but with tuples. */
 template<typename, typename>
-struct is_applicable: std::false_type {};
+struct is_applicable: stl::false_type {};
 
 /**
  * @copybrief is_applicable
@@ -609,7 +609,7 @@ inline constexpr bool is_applicable_v = is_applicable<Func, Args>::value;
 
 /*! @brief Same as std::is_invocable_r, but with tuples for arguments. */
 template<typename, typename, typename>
-struct is_applicable_r: std::false_type {};
+struct is_applicable_r: stl::false_type {};
 
 /**
  * @copybrief is_applicable_r
@@ -637,12 +637,12 @@ inline constexpr bool is_applicable_r_v = is_applicable_r<Ret, Func, Args>::valu
  * @tparam Type The type to test.
  */
 template<typename Type>
-struct is_complete: std::false_type {};
+struct is_complete: stl::false_type {};
 
 /*! @copydoc is_complete */
 template<typename Type>
 requires requires { sizeof(Type); }
-struct is_complete<Type>: std::true_type {};
+struct is_complete<Type>: stl::true_type {};
 
 /**
  * @brief Helper variable template.
@@ -657,17 +657,17 @@ inline constexpr bool is_complete_v = is_complete<Type>::value;
  * @tparam Type The type to test.
  */
 template<typename Type>
-struct is_iterator: std::false_type {};
+struct is_iterator: stl::false_type {};
 
 /*! @cond ENTT_INTERNAL */
 namespace internal {
 
 template<typename>
-struct has_iterator_category: std::false_type {};
+struct has_iterator_category: stl::false_type {};
 
 template<typename Type>
 requires requires { typename stl::iterator_traits<Type>::iterator_category; }
-struct has_iterator_category<Type>: std::true_type {};
+struct has_iterator_category<Type>: stl::true_type {};
 
 } // namespace internal
 /*! @endcond */
@@ -705,12 +705,12 @@ inline constexpr bool is_ebco_eligible_v = is_ebco_eligible<Type>::value;
  * @tparam Type The type to test.
  */
 template<typename Type>
-struct is_transparent: std::false_type {};
+struct is_transparent: stl::false_type {};
 
 /*! @copydoc is_transparent */
 template<typename Type>
 requires requires { typename Type::is_transparent; }
-struct is_transparent<Type>: std::true_type {};
+struct is_transparent<Type>: stl::true_type {};
 
 /**
  * @brief Helper variable template.
@@ -723,18 +723,18 @@ inline constexpr bool is_transparent_v = is_transparent<Type>::value;
 namespace internal {
 
 template<typename>
-struct has_tuple_size_value: std::false_type {};
+struct has_tuple_size_value: stl::false_type {};
 
 template<typename Type>
 requires is_complete_v<stl::tuple_size<const Type>>
-struct has_tuple_size_value<Type>: std::true_type {};
+struct has_tuple_size_value<Type>: stl::true_type {};
 
 template<typename>
-struct has_value_type: std::false_type {};
+struct has_value_type: stl::false_type {};
 
 template<typename Type>
 requires requires { typename Type::value_type; }
-struct has_value_type<Type>: std::true_type {};
+struct has_value_type<Type>: stl::true_type {};
 
 template<typename>
 [[nodiscard]] ENTT_CONSTEVAL bool dispatch_is_equality_comparable();

src/entt/entity/component.hpp

@@ -17,11 +17,11 @@ template<typename Type>
 struct in_place_delete: std::bool_constant<!(std::is_move_constructible_v<Type> && std::is_move_assignable_v<Type>)> {};
 
 template<>
-struct in_place_delete<void>: std::false_type {};
+struct in_place_delete<void>: stl::false_type {};
 
 template<typename Type>
 requires Type::in_place_delete
-struct in_place_delete<Type>: std::true_type {};
+struct in_place_delete<Type>: stl::true_type {};
 
 template<typename Type>
 struct page_size: std::integral_constant<std::size_t, !std::is_empty_v<ENTT_ETO_TYPE(Type)> * ENTT_PACKED_PAGE> {};

src/entt/entity/mixin.hpp

@@ -19,25 +19,25 @@ namespace entt {
 namespace internal {
 
 template<typename, typename>
-struct has_on_construct final: std::false_type {};
+struct has_on_construct final: stl::false_type {};
 
 template<typename Type, typename Registry>
 requires std::invocable<decltype(&Type::on_construct), Registry &, typename Registry::entity_type>
-struct has_on_construct<Type, Registry>: std::true_type {};
+struct has_on_construct<Type, Registry>: stl::true_type {};
 
 template<typename, typename>
-struct has_on_update final: std::false_type {};
+struct has_on_update final: stl::false_type {};
 
 template<typename Type, typename Registry>
 requires std::invocable<decltype(&Type::on_update), Registry &, typename Registry::entity_type>
-struct has_on_update<Type, Registry>: std::true_type {};
+struct has_on_update<Type, Registry>: stl::true_type {};
 
 template<typename, typename>
-struct has_on_destroy final: std::false_type {};
+struct has_on_destroy final: stl::false_type {};
 
 template<typename Type, typename Registry>
 requires std::invocable<decltype(&Type::on_destroy), Registry &, typename Registry::entity_type>
-struct has_on_destroy<Type, Registry>: std::true_type {};
+struct has_on_destroy<Type, Registry>: stl::true_type {};
 
 } // namespace internal
 /*! @endcond */

src/entt/entity/organizer.hpp

@@ -19,19 +19,19 @@ namespace entt {
 namespace internal {
 
 template<typename>
-struct is_view: std::false_type {};
+struct is_view: stl::false_type {};
 
 template<typename... Args>
-struct is_view<basic_view<Args...>>: std::true_type {};
+struct is_view<basic_view<Args...>>: stl::true_type {};
 
 template<typename Type>
 inline constexpr bool is_view_v = is_view<Type>::value;
 
 template<typename>
-struct is_group: std::false_type {};
+struct is_group: stl::false_type {};
 
 template<typename... Args>
-struct is_group<basic_group<Args...>>: std::true_type {};
+struct is_group<basic_group<Args...>>: stl::true_type {};
 
 template<typename Type>
 inline constexpr bool is_group_v = is_group<Type>::value;

src/entt/meta/pointer.hpp

@@ -16,7 +16,7 @@ namespace entt {
  */
 template<typename Type>
 struct is_meta_pointer_like<std::shared_ptr<Type>>
-    : std::true_type {};
+    : stl::true_type {};
 
 /**
  * @brief Makes `std::unique_ptr`s of any type pointer-like types for the meta
@@ -26,7 +26,7 @@ struct is_meta_pointer_like<std::shared_ptr<Type>>
  */
 template<typename Type, typename... Args>
 struct is_meta_pointer_like<std::unique_ptr<Type, Args...>>
-    : std::true_type {};
+    : stl::true_type {};
 
 /**
  * @brief Specialization for self-proclaimed meta pointer like types.
@@ -35,7 +35,7 @@ struct is_meta_pointer_like<std::unique_ptr<Type, Args...>>
 template<typename Type>
 requires requires { typename Type::is_meta_pointer_like; }
 struct is_meta_pointer_like<Type>
-    : std::true_type {};
+    : stl::true_type {};
 
 } // namespace entt
 

src/entt/meta/type_traits.hpp

@@ -32,7 +32,7 @@ struct meta_associative_container_traits;
  * pointer-like type from the point of view of the meta system, false otherwise.
  */
 template<typename>
-struct is_meta_pointer_like: std::false_type {};
+struct is_meta_pointer_like: stl::false_type {};
 
 /**
  * @brief Partial specialization to ensure that const pointer-like types are

src/entt/stl/type_traits.hpp

@@ -6,12 +6,14 @@
 /*! @cond ENTT_INTERNAL */
 namespace entt::stl {
 
+using std::false_type;
 using std::invoke_result_t;
 using std::is_invocable_r_v;
 using std::is_member_object_pointer_v;
 using std::is_same_v;
 using std::remove_cvref_t;
 using std::remove_pointer_t;
+using std::true_type;
 
 } // namespace entt::stl
 /*! @endcond */