From f82ed7b744b25e069b314a89033a527208972182 Mon Sep 17 00:00:00 2001
From: owent <admin@owent.net>
Date: Wed, 27 May 2026 15:06:23 +0800
Subject: [PATCH] Fixes N5014 warning

---
 include/memory/allocator_traits.h | 483 ++++++++++--------------------
 test/case/wal_object_test.cpp     |  44 ++-
 2 files changed, 177 insertions(+), 350 deletions(-)

diff --git a/include/memory/allocator_traits.h b/include/memory/allocator_traits.h
index abdda95e..ce20ddac 100644
--- a/include/memory/allocator_traits.h
+++ b/include/memory/allocator_traits.h
@@ -2,47 +2,36 @@
 //
 // Licenses under the MIT License
 //
-// @note This is a helper class for user to implement a standard allocator and allocator_traits more easily.
+// @note These helpers make it easier to implement standard-compatible allocators.
 // @example
 //   ```cpp
 //   template <class T, class BackendAllocator = ::std::allocator<T>>
-//   struct custom_allocator : public ::std::allocator<T> {
-//       T* allocate(::std::size_t n) { /* ... */ };
-//       void deallocate(T* p, ::std::size_t n) { /* ... */ };
-//      template <class U>
-//      struct rebind {
-//        /* Recursive rebind backend allocator(traditional way) */
-//        using __rebind_backend_type_other =
-//            typename ::std::allocator_traits<BackendAllocator>::template rebind_alloc<U>;
-//        using other = allocator<U, __rebind_backend_type_other>;
-//      };
-//   };
+//   struct custom_allocator
+//       : public ::atfw::util::memory::allocator_adapter<custom_allocator, T, BackendAllocator> {
+//     using base_type = ::atfw::util::memory::allocator_adapter<custom_allocator, T, BackendAllocator>;
+//     using pointer = typename base_type::pointer;
+//     using size_type = typename base_type::size_type;
 //
-//   /* Just use codes below to support standard allocator_traits for custom_allocator */
-//   namespace std {
-//   template <class T, class BackendAllocator>
-//   struct allocator_traits<custom_allocator<T, BackendAllocator>>
-//       : public ::atfw::util::memory::allocator_traits<custom_allocator<T, BackendAllocator>> {
-//     template <typename U>
-//     using rebind_alloc = custom_allocator<T,
-//       /* Rebind backend allocator(modern way) */
-//       typename ::std::allocator_traits<BackendAllocator>::template rebind_alloc<U>>;
+//     using base_type::base_type;
 //
-//     template <typename U>
-//     using rebind_traits = allocator_traits<rebind_alloc<U>>;
+//     pointer allocate(size_type n) { /* custom logic */ return base_type::allocate(n); }
+//     void deallocate(pointer p, size_type n) { /* custom logic */ base_type::deallocate(p, n); }
 //   };
-//   }  // namespace std
+//
+//   using custom_allocator_traits = ::std::allocator_traits<custom_allocator<int>>;
 //   ```
+// @note Never specialize ::std::allocator_traits for user allocators. Standard library templates are not extension
+// points; put customization on the allocator type itself and let the standard traits primary template detect it.
 
 #pragma once
 
 #include <config/atframe_utils_build_feature.h>
 
 #include <config/compile_optimize.h>
-#include <nostd/type_traits.h>
+#include <std/explicit_declare.h>
 
-#include <limits>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 // STL declare allocator's callbacks as constexpr since C++20, we keep the same behavior for compatibility
@@ -60,9 +49,7 @@
 #    pragma warning(disable : 4996)
 #  endif
 #elif defined(__GNUC__) && !defined(__clang__) && !defined(__apple_build_version__)
-#  if (__GNUC__ * 100 + __GNUC_MINOR__ * 10) >= 460
-#    pragma GCC diagnostic push
-#  endif
+#  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wdeprecated"
 #elif defined(__clang__) || defined(__apple_build_version__)
 #  pragma clang diagnostic push
@@ -71,358 +58,206 @@
 
 ATFRAMEWORK_UTILS_NAMESPACE_BEGIN
 namespace memory {
-// NOLINTBEGIN(bugprone-macro-parentheses)
-
-// __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE is used to bind allocator's nested type to allocator_traits
-// It will try to use allocator's nested type first, if not exists, it will use default type according to ISO instead.
-// @see https://en.cppreference.com/w/cpp/memory/allocator_traits
-#if ((defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L))
-// Not all compilers support detected_or for template template_args now
-#  if 0 && (defined(__cpp_template_template_args) && __cpp_template_template_args)
-#    define __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(TEST_CLASS, NESTED_TYPE, TYPE_ALIAS, DEFAULT_TYPE) \
-     private:                                                                                                       \
-      template <class __TCNT>                                                                                       \
-      using __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE = typename TEST_CLASS::NESTED_TYPE;  \
-                                                                                                                    \
-     public:                                                                                                        \
-      using TYPE_ALIAS =                                                                                            \
-          __nested_type_detected_or_t<DEFAULT_TYPE,                                                                 \
-                                      __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE, TEST_CLASS>
-#  else
-#    if defined(__cpp_concepts) && __cpp_concepts
-#      define __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(TEST_CLASS, NESTED_TYPE, TYPE_ALIAS, DEFAULT_TYPE) \
-       private:                                                                                                       \
-        template <class DefaultType, class TemplateType>                                                              \
-        struct __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE {                                   \
-          using type = DefaultType;                                                                                   \
-          using value_t = ::std::false_type;                                                                          \
-        };                                                                                                            \
-        template <class DefaultType, class TemplateType>                                                              \
-          requires requires { typename TemplateType::NESTED_TYPE; }                                                   \
-        struct __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE<DefaultType, TemplateType> {        \
-          using type = typename TemplateType::NESTED_TYPE;                                                            \
-          using value_t = ::std::true_type;                                                                           \
-        };                                                                                                            \
-                                                                                                                      \
-       public:                                                                                                        \
-        using TYPE_ALIAS =                                                                                            \
-            typename __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE<DEFAULT_TYPE,                 \
-                                                                                        TEST_CLASS>::type
-
-#    else
-#      define __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(TEST_CLASS, NESTED_TYPE, TYPE_ALIAS, DEFAULT_TYPE) \
-       private:                                                                                                       \
-        template <class DefaultType, class TemplateType, class = void>                                                \
-        struct __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE {                                   \
-          using type = DefaultType;                                                                                   \
-          using value_t = ::std::false_type;                                                                          \
-        };                                                                                                            \
-        template <class DefaultType, class TemplateType>                                                              \
-        struct __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE<                                    \
-            DefaultType, TemplateType, ::std::void_t<typename TemplateType::NESTED_TYPE>> {                           \
-          using type = typename TemplateType::NESTED_TYPE;                                                            \
-          using value_t = ::std::true_type;                                                                           \
-        };                                                                                                            \
-                                                                                                                      \
-       public:                                                                                                        \
-        using TYPE_ALIAS =                                                                                            \
-            typename __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE<DEFAULT_TYPE,                 \
-                                                                                        TEST_CLASS>::type
-#    endif
-#  endif
-#else
-#  define __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(TEST_CLASS, NESTED_TYPE, TYPE_ALIAS, DEFAULT_TYPE)    \
-   private:                                                                                                          \
-    template <class __TCNT>                                                                                          \
-    static typename __TCNT::NESTED_TYPE __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE##_helper( \
-        __TCNT*);                                                                                                    \
-    static DEFAULT_TYPE __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE##_helper(...);            \
-                                                                                                                     \
-   public:                                                                                                           \
-    using TYPE_ALIAS = decltype(__util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE_##NESTED_TYPE##_helper(         \
-        static_cast<TEST_CLASS*>(nullptr)))
-#endif
+template <class BackendAllocator>
+class __util_memory_allocator_adapter_is_always_equal {
+  template <class AllocatorOther>
+  static typename AllocatorOther::is_always_equal _S_test(int);
 
-// NOLINTEND(bugprone-macro-parentheses)
-
-// Inject std::allocator_traits for util_memory_allocator_traits::allocator
-template <class AllocatorSource, class TypeSource>
-class __util_memory_allocator_traits_allocator_rebind_detect_other {
-  template <class AllocatorTarget, class TypeTarget>
-  static UTIL_CONFIG_CONSTEXPR bool _util_memory_allocator_traits_chk(
-      typename AllocatorTarget::template rebind<TypeTarget>::other*) {
-    return true;
-  }
-
-  template <class, class>
-  static UTIL_CONFIG_CONSTEXPR bool _util_memory_allocator_traits_chk(...) {
-    return false;
-  }
+  template <class>
+  static typename ::std::is_empty<BackendAllocator>::type _S_test(...);
 
  public:
-  static UTIL_CONFIG_CONSTEXPR const bool __value =
-      _util_memory_allocator_traits_chk<AllocatorSource, TypeSource>(nullptr);
+  using type = decltype(_S_test<BackendAllocator>(0));
 };
 
-#if !((defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L))
-template <class Allocator, class T>
-UTIL_CONFIG_CONSTEXPR const bool __util_memory_allocator_traits_allocator_rebind_detect_other<Allocator, T>::__value;
-#endif
+template <class LeftBackendAllocator, class RightBackendAllocator>
+class __util_memory_allocator_adapter_backend_equal {
+  template <class LeftAllocator, class RightAllocator>
+  static auto _S_check(int)
+      -> decltype(::std::declval<const LeftAllocator&>() == ::std::declval<const RightAllocator&>(),
+                  ::std::true_type());
 
-template <class Allocator, class T,
-          bool = __util_memory_allocator_traits_allocator_rebind_detect_other<Allocator, T>::__value>
-struct __util_memory_allocator_traits_allocator_allocator_rebind;
+  template <class, class>
+  static ::std::false_type _S_check(...);
 
-template <class Allocator, class T>
-struct __util_memory_allocator_traits_allocator_allocator_rebind<Allocator, T, true> {
-  using __rebind_type_other = typename Allocator::template rebind<T>;
-  using type = typename __rebind_type_other::other;
-};
+  using has_equal = decltype(_S_check<LeftBackendAllocator, RightBackendAllocator>(0));
 
-template <template <class, class...> class Allocator, class T, class Up, class... Args>
-struct __util_memory_allocator_traits_allocator_allocator_rebind<Allocator<Up, Args...>, T, false> {
-  using type = Allocator<T, Args...>;
-};
+  static bool _S_equal(const LeftBackendAllocator& left, const RightBackendAllocator& right,
+                       ::std::true_type) noexcept(noexcept(left == right)) {
+    return left == right;
+  }
 
-// Non-standard RAII type for managing pointers obtained from allocators.
-// Just delcare it in std namespace to make allocator compatible with std::allocator_traits
-template <class Alloc>
-struct ATFW_UTIL_SYMBOL_VISIBLE allocator_traits {
-  using allocator_type = Alloc;
-  using value_type = typename allocator_type::value_type;
-
-#if ((defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L))
-// Many compilers have problems in detected_or for template template_args now, we turn it on when it's ready in the
-// future.
-#  if 0 && (defined(__cpp_template_template_args) && __cpp_template_template_args)
-#    if defined(__cpp_concepts) && __cpp_concepts >= 202002L
-  // Implementation of the detection idiom (negative case).
-  template <class DefaultType, template <class...> class DetectTemplateType, class... TemplateArgs>
-  struct __nested_type_detected_or {
-    using type = DefaultType;
-    using value_t = ::std::false_type;
-  };
+  static bool _S_equal(const LeftBackendAllocator&, const RightBackendAllocator&, ::std::false_type) noexcept {
+    return __util_memory_allocator_adapter_is_always_equal<LeftBackendAllocator>::type::value &&
+           __util_memory_allocator_adapter_is_always_equal<RightBackendAllocator>::type::value;
+  }
 
-  // Implementation of the detection idiom (positive case).
-  template <class DefaultType, template <class...> class DetectTemplateType, class... TemplateArgs>
-    requires requires { typename DetectTemplateType<TemplateArgs...>; }
-  struct __nested_type_detected_or<DefaultType, DetectTemplateType, TemplateArgs...> {
-    using type = DetectTemplateType<TemplateArgs...>;
-    using value_t = ::std::true_type;
-  };
-#    else
-  /// Implementation of the detection idiom (negative case).
-  template <class DefaultType, class _AlwaysVoid, template <class...> class DetectTemplateType, class... TemplateArgs>
-  struct __nested_type_detector {
-    using type = DefaultType;
-    using value_t = ::std::false_type;
-  };
+ public:
+  static bool equal(const LeftBackendAllocator& left,
+                    const RightBackendAllocator& right) noexcept(noexcept(_S_equal(left, right, has_equal()))) {
+    return _S_equal(left, right, has_equal());
+  }
+};
 
-  /// Implementation of the detection idiom (positive case).
-  template <class DefaultType, template <class...> class DetectTemplateType, class... TemplateArgs>
-  struct __nested_type_detector<DefaultType, ::std::void_t<DetectTemplateType<TemplateArgs...>>, DetectTemplateType,
-                                TemplateArgs...> {
-    using type = DetectTemplateType<TemplateArgs...>;
-    using value_t = ::std::true_type;
+// A CRTP-style adapter for building allocators from an existing backend allocator.
+// Users inherit from allocator_adapter<user_allocator, T, BackendAllocator> and only override the operations that need
+// custom behavior. The inherited nested types, rebind, construction, destruction, and backend forwarding operations are
+// visible to ::std::allocator_traits<user_allocator<T, BackendAllocator>> without specializing std::allocator_traits.
+template <template <class, class> class Allocator, class T, class BackendAllocator = ::std::allocator<T>>
+class ATFW_UTIL_SYMBOL_VISIBLE allocator_adapter {
+ public:
+  using allocator_type = Allocator<T, BackendAllocator>;
+  using backend_allocator_type = BackendAllocator;
+  using backend_allocator_traits = ::std::allocator_traits<backend_allocator_type>;
+  using value_type = T;
+  using pointer = typename backend_allocator_traits::pointer;
+  using const_pointer = typename backend_allocator_traits::const_pointer;
+  using void_pointer = typename backend_allocator_traits::void_pointer;
+  using const_void_pointer = typename backend_allocator_traits::const_void_pointer;
+  using difference_type = typename backend_allocator_traits::difference_type;
+  using size_type = typename backend_allocator_traits::size_type;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using propagate_on_container_copy_assignment =
+      typename backend_allocator_traits::propagate_on_container_copy_assignment;
+  using propagate_on_container_move_assignment =
+      typename backend_allocator_traits::propagate_on_container_move_assignment;
+  using propagate_on_container_swap = typename backend_allocator_traits::propagate_on_container_swap;
+  using is_always_equal = typename __util_memory_allocator_adapter_is_always_equal<backend_allocator_type>::type;
+
+  template <class U>
+  struct rebind {
+    using __rebind_backend_type_other = typename backend_allocator_traits::template rebind_alloc<U>;
+    using other = Allocator<U, __rebind_backend_type_other>;
   };
 
-  template <class DefaultType, template <class...> class DetectTemplateType, class... TemplateArgs>
-  using __nested_type_detected_or = __nested_type_detector<DefaultType, void, DetectTemplateType, TemplateArgs...>;
-#    endif  // __cpp_concepts
-
-  template <class DefaultType, template <class...> class DetectTemplateType, class... TemplateArgs>
-  using __nested_type_detected_or_t =
-      typename __nested_type_detected_or<DefaultType, DetectTemplateType, TemplateArgs...>::type;
-#  endif
-#endif
-
-  // Rebind types for allocator_traits
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, pointer, pointer, value_type*);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(
-      allocator_type, const_pointer, const_pointer,
-      typename ::std::pointer_traits<pointer>::template rebind<const value_type>);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, void_pointer, void_pointer,
-                                                       typename ::std::pointer_traits<pointer>::template rebind<void>);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(
-      allocator_type, const_void_pointer, const_void_pointer,
-      typename ::std::pointer_traits<pointer>::template rebind<const void>);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, difference_type, difference_type,
-                                                       typename ::std::pointer_traits<pointer>::difference_type);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, size_type, size_type,
-                                                       typename ::std::make_unsigned<difference_type>::type);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, propagate_on_container_copy_assignment,
-                                                       propagate_on_container_copy_assignment, ::std::false_type);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, propagate_on_container_move_assignment,
-                                                       propagate_on_container_move_assignment, ::std::false_type);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, propagate_on_container_swap,
-                                                       propagate_on_container_swap, ::std::false_type);
-  __util_memory_allocator_traits_ALLOCATOR_NESTED_TYPE(allocator_type, is_always_equal, is_always_equal,
-                                                       typename ::std::is_empty<allocator_type>::type);
-
-  template <typename U>
-  using rebind_alloc = typename __util_memory_allocator_traits_allocator_allocator_rebind<allocator_type, U>::type;
-
-  template <typename U>
-  using rebind_traits = allocator_traits<rebind_alloc<U>>;
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_adapter() noexcept(
+      ::std::is_nothrow_default_constructible<backend_allocator_type>::value)
+      : backend_allocator_() {}
 
-  ATFW_EXPLICIT_NODISCARD_ATTR
-      ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR pointer
-      allocate(allocator_type& a, size_type n) {
-    return a.allocate(n);
-  }
+  inline explicit ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR
+  allocator_adapter(const backend_allocator_type& backend) noexcept(
+      ::std::is_nothrow_copy_constructible<backend_allocator_type>::value)
+      : backend_allocator_(backend) {}
 
- private:
-  // allocate
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static auto _S_allocate(AllocOther& __a, size_type __n, const_void_pointer __hint,
-                                                          int) -> decltype(__a.allocate(__n, __hint)) {
-    return __a.allocate(__n, __hint);
-  }
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_adapter(const allocator_adapter&) noexcept(
+      ::std::is_nothrow_copy_constructible<backend_allocator_type>::value) = default;
 
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static pointer _S_allocate(AllocOther& __a, size_type __n, ...) {
-    return __a.allocate(__n);
-  }
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_adapter(allocator_adapter&&) noexcept(
+      ::std::is_nothrow_move_constructible<backend_allocator_type>::value) = default;
 
-  // construct
-  template <typename U, typename... _Args>
-  struct __construct_helper {
-    template <typename AllocOther,
-              typename = decltype(std::declval<AllocOther*>()->construct(std::declval<U*>(), std::declval<_Args>()...))>
-    static ::std::true_type __test(int);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_adapter& operator=(const allocator_adapter&) noexcept(
+      ::std::is_nothrow_copy_assignable<backend_allocator_type>::value) = default;
 
-    template <typename>
-    static ::std::false_type __test(...);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_adapter& operator=(allocator_adapter&&) noexcept(
+      ::std::is_nothrow_move_assignable<backend_allocator_type>::value) = default;
 
-    using type = decltype(__test<allocator_type>(0));
-    static UTIL_CONFIG_CONSTEXPR const bool value = type::value;
-  };
-
-  // Constroctor
-  // Using the allocator's constructor, keep the same exception specification as the allocator's construct
-  template <typename U, typename... _Args>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR
-      ATFRAMEWORK_UTILS_NAMESPACE_ID::nostd::enable_if_t<__construct_helper<U, _Args...>::value, void>
-      _S_construct(allocator_type& __a, U* __p,
-                   _Args&&... __args) noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) {
-    __a.construct(__p, std::forward<_Args>(__args)...);
-  }
-
-  // Using the default constructor, keep the same exception specification as the default constructor
-  template <typename U, typename... _Args>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR ATFRAMEWORK_UTILS_NAMESPACE_ID::
-      nostd::enable_if_t<!__construct_helper<U, _Args...>::value && ::std::is_constructible<U, _Args...>::value, void>
-      _S_construct(allocator_type&, U* __p,
-                   _Args&&... __args) noexcept(std::is_nothrow_constructible<U, _Args...>::value) {
-#if ((defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L))
-    ::std::construct_at(__p, std::forward<_Args>(__args)...);
-#else
-    ::new ((void*)__p) U(std::forward<_Args>(__args)...);  // NOLINT: readability/casting
-#endif
-  }
+  template <class U, class UBackendAllocator>
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR
+  allocator_adapter(const allocator_adapter<Allocator, U, UBackendAllocator>& other) noexcept(
+      ::std::is_nothrow_constructible<backend_allocator_type, const UBackendAllocator&>::value)
+      : backend_allocator_(other.backend_allocator()) {}
 
-  // destroy
-  // Using the allocator's destroy callback, keep the same exception specification as the allocator's callback
-  template <typename AllocatorOther, typename U>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR auto _S_destroy(
-      AllocatorOther& __a, U* __p, int) noexcept(noexcept(__a.destroy(__p))) -> decltype(__a.destroy(__p)) {
-    __a.destroy(__p);
-  }
+  template <class U, class UBackendAllocator>
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR
+  allocator_adapter(allocator_adapter<Allocator, U, UBackendAllocator>&& other) noexcept(
+      ::std::is_nothrow_constructible<backend_allocator_type, UBackendAllocator&&>::value)
+      : backend_allocator_(::std::move(other.backend_allocator())) {}
 
-  // Using the default destroy function, keep the same exception specification as the default destroy function
-  template <typename AllocatorOther, typename U>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR void _S_destroy(
-      AllocatorOther&, U* __p, ...) noexcept(std::is_nothrow_destructible<U>::value) {
-#if ((defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L))
-    ::std::destroy_at(__p);
-#else
-    __p->~U();
-#endif
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR backend_allocator_type& backend_allocator() noexcept {
+    return backend_allocator_;
   }
 
-  // max_size
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR auto _S_max_size(
-      const AllocOther& __a, int) -> decltype(__a.max_size()) {
-    return __a.max_size();
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR const backend_allocator_type& backend_allocator() const noexcept {
+    return backend_allocator_;
   }
 
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR size_type
-  _S_max_size(const AllocOther&, ...) {
-    return ::std::numeric_limits<size_type>::max();
+ private:
+  template <class AllocatorOther>
+  inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR auto _S_allocate(AllocatorOther& allocator, size_type n,
+                                                                              const_void_pointer hint, int)
+      -> decltype(allocator.allocate(n, hint)) {
+    return allocator.allocate(n, hint);
   }
 
-  // select_on_container_copy_construction
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR auto _S_select(AllocOther& __a,
-                                                                                                     int)
-      -> decltype(__a.select_on_container_copy_construction()) {
-    return __a.select_on_container_copy_construction();
+  template <class AllocatorOther>
+  inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR pointer _S_allocate(AllocatorOther& allocator, size_type n,
+                                                                                 const_void_pointer, ...) {
+    return ::std::allocator_traits<AllocatorOther>::allocate(allocator, n);
   }
 
-  template <typename AllocOther>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR AllocOther
-  _S_select(AllocOther& __a, ...) {
-    return __a;
+ public:
+  ATFW_EXPLICIT_NODISCARD_ATTR
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR pointer allocate(size_type n) {
+    return backend_allocator_traits::allocate(backend_allocator_, n);
   }
 
- public:
   ATFW_EXPLICIT_NODISCARD_ATTR
-      ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR pointer
-      allocate(allocator_type& a, size_type n, const_void_pointer hint) {
-    return _S_allocate(a, n, hint, 0);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR pointer allocate(size_type n, const_void_pointer hint) {
+    return _S_allocate(backend_allocator_, n, hint, 0);
   }
 
 #if ((defined(__cplusplus) && __cplusplus >= 202302L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202302L)) && \
     defined(__cpp_lib_allocate_at_least) && __cpp_lib_allocate_at_least >= 202302L
   ATFW_EXPLICIT_NODISCARD_ATTR
-  ATFW_UTIL_SYMBOL_VISIBLE inline static UTIL_CONFIG_CONSTEXPR ::std::allocation_result<pointer, size_type>
-  allocate_at_least(allocator_type& a, size_type n) {
-    return a.allocate_at_least(n);
+  inline UTIL_CONFIG_CONSTEXPR ::std::allocation_result<pointer, size_type> allocate_at_least(size_type n) {
+    return backend_allocator_traits::allocate_at_least(backend_allocator_, n);
   }
 #endif
 
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR void deallocate(allocator_type& a,
-                                                                                                      pointer p,
-                                                                                                      size_type n) {
-    a.deallocate(p, n);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR void deallocate(pointer p, size_type n) {
+    backend_allocator_traits::deallocate(backend_allocator_, p, n);
   }
 
-  template <class T, class... Args>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static UTIL_CONFIG_CONSTEXPR void construct(
-      allocator_type& a, T* p, Args&&... args) noexcept(noexcept(_S_construct(a, p, std::forward<Args>(args)...))) {
-    _S_construct(a, p, std::forward<Args>(args)...);
+  template <class U, class... Args>
+  inline UTIL_CONFIG_CONSTEXPR void construct(U* p, Args&&... args) noexcept(
+      noexcept(backend_allocator_traits::construct(backend_allocator_, p, ::std::forward<Args>(args)...))) {
+    backend_allocator_traits::construct(backend_allocator_, p, ::std::forward<Args>(args)...);
   }
 
-  template <class T>
-  ATFW_UTIL_SYMBOL_VISIBLE inline static UTIL_CONFIG_CONSTEXPR void destroy(allocator_type& a,
-                                                                            T* p) noexcept(noexcept(_S_destroy(a, p,
-                                                                                                               0))) {
-    _S_destroy(a, p, 0);
+  template <class U>
+  inline UTIL_CONFIG_CONSTEXPR void destroy(U* p) noexcept(
+      noexcept(backend_allocator_traits::destroy(backend_allocator_, p))) {
+    backend_allocator_traits::destroy(backend_allocator_, p);
   }
 
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR size_type
-  max_size(const allocator_type& a) noexcept {
-    return _S_max_size(a, 0);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR size_type max_size() const
+      noexcept(noexcept(backend_allocator_traits::max_size(backend_allocator_))) {
+    return backend_allocator_traits::max_size(backend_allocator_);
   }
 
-  ATFW_UTIL_SYMBOL_VISIBLE inline static ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_type
-  select_on_container_copy_construction(const allocator_type& a) {
-    return _S_select(a, 0);
+  inline ATFRAMEWORK_UTILS_MEMORY_ALLOCATOR_CONSTEXPR allocator_type select_on_container_copy_construction() const {
+    return static_cast<const allocator_type&>(*this);
   }
+
+ private:
+  backend_allocator_type backend_allocator_;
 };
 
+template <template <class, class> class Allocator, class T, class BackendAllocator, class U, class UBackendAllocator>
+ATFW_UTIL_SYMBOL_VISIBLE inline bool operator==(
+    const allocator_adapter<Allocator, T, BackendAllocator>& left,
+    const allocator_adapter<Allocator, U, UBackendAllocator>&
+        right) noexcept(noexcept(__util_memory_allocator_adapter_backend_equal<BackendAllocator, UBackendAllocator>::
+                                     equal(left.backend_allocator(), right.backend_allocator()))) {
+  return __util_memory_allocator_adapter_backend_equal<BackendAllocator, UBackendAllocator>::equal(
+      left.backend_allocator(), right.backend_allocator());
+}
+
+template <template <class, class> class Allocator, class T, class BackendAllocator, class U, class UBackendAllocator>
+ATFW_UTIL_SYMBOL_VISIBLE inline bool operator!=(
+    const allocator_adapter<Allocator, T, BackendAllocator>& left,
+    const allocator_adapter<Allocator, U, UBackendAllocator>& right) noexcept(noexcept(!(left == right))) {
+  return !(left == right);
+}
+
 }  // namespace memory
 ATFRAMEWORK_UTILS_NAMESPACE_END
 
 #if defined(_MSC_VER)
 #  pragma warning(pop)
 #elif defined(__GNUC__) && !defined(__clang__) && !defined(__apple_build_version__)
-#  if (__GNUC__ * 100 + __GNUC_MINOR__ * 10) >= 460
-#    pragma GCC diagnostic pop
-#  endif
+#  pragma GCC diagnostic pop
 #elif defined(__clang__) || defined(__apple_build_version__)
 #  pragma clang diagnostic pop
 #endif
-
diff --git a/test/case/wal_object_test.cpp b/test/case/wal_object_test.cpp
index c045fadb..957fd9e1 100644
--- a/test/case/wal_object_test.cpp
+++ b/test/case/wal_object_test.cpp
@@ -1524,48 +1524,41 @@ struct test_wal_object_test_allocator_storage {
   inline test_wal_object_test_allocator_storage() {}
 };
 
-template <class T>
-struct test_wal_object_test_allocator : public ::std::allocator<T> {
-  template <class U>
-  struct rebind {
-    using other = test_wal_object_test_allocator<U>;
-  };
-
-  WAL_TEST_ALLOCATOR_CONSTEXPR T* allocate(::std::size_t n) {
+template <class T, class BackendAllocator = ::std::allocator<T>>
+struct test_wal_object_test_allocator
+    : public ::atfw::util::memory::allocator_adapter<test_wal_object_test_allocator, T, BackendAllocator> {
+  using base_type = ::atfw::util::memory::allocator_adapter<test_wal_object_test_allocator, T, BackendAllocator>;
+  using pointer = typename base_type::pointer;
+  using size_type = typename base_type::size_type;
+
+  WAL_TEST_ALLOCATOR_CONSTEXPR pointer allocate(size_type n) {
     storage->allocate_counter += n;
-    return ::std::allocator<T>::allocate(n);
+    return base_type::allocate(n);
   }
 
 #if !((defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L))
-  T* allocate(::std::size_t n, const void* hint) {
+  pointer allocate(size_type n, typename base_type::const_void_pointer hint) {
     storage->allocate_counter += n;
-    return std::allocator<T>::allocate(n, hint);
+    return base_type::allocate(n, hint);
   }
 #endif
 
-  void deallocate(T* p, ::std::size_t n) {
+  void deallocate(pointer p, size_type n) {
     storage->deallocate_counter += n;
-    std::allocator<T>::deallocate(p, n);
+    base_type::deallocate(p, n);
   }
 
   std::shared_ptr<test_wal_object_test_allocator_storage> storage;
 
   inline test_wal_object_test_allocator() noexcept
-      : storage(std::make_shared<test_wal_object_test_allocator_storage>()) {}
+      : base_type(), storage(std::make_shared<test_wal_object_test_allocator_storage>()) {}
 
-  template <class U>
-  inline test_wal_object_test_allocator(const test_wal_object_test_allocator<U>& other) noexcept
-      : storage(other.storage) {}  // NOLINT: runtime/explicit
+  template <class U, class UBackendAllocator>
+  inline test_wal_object_test_allocator(const test_wal_object_test_allocator<U, UBackendAllocator>& other) noexcept
+      : base_type(static_cast<const typename test_wal_object_test_allocator<U, UBackendAllocator>::base_type&>(other)),
+        storage(other.storage) {}  // NOLINT: runtime/explicit
 };
 
-}  // namespace st
-namespace std {
-template <class T>
-struct allocator_traits<st::test_wal_object_test_allocator<T>>
-    : public ::atfw::util::memory::allocator_traits<st::test_wal_object_test_allocator<T>> {};
-}  // namespace std
-
-namespace st {
 CASE_TEST(wal_object, with_allocator) {
   test_wal_object_log_storage_type storage;
   test_wal_object_context ctx;
@@ -1598,4 +1591,3 @@ CASE_TEST(wal_object, with_allocator) {
 }
 
 }  // namespace st
-