STL compatibility fixes

Author: cas4ey

include/shared_allocator/cached_allocator.hpp

@@ -140,11 +140,24 @@ namespace salloc {
 
         Does nothing and returns reference to this allocator. */
         template <class U>
-        ThisType& operator=(const U&)
+        ThisType& operator = (const U&)
         {
             return *this;
         }
 
+        /** Operator == for STL compatibility. */
+        inline bool operator == (const ThisType&) throw()
+        {
+            return true;
+        }
+
+        /** Operator == for STL compatibility. */
+        template <class U, class W>
+        inline bool operator == (const cached_allocator<U, W>&) throw()
+        {
+            return false;
+        }
+
         ~cached_allocator()
         {
             private_clear();
@@ -337,21 +350,6 @@ namespace salloc {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-/** Operator == for STL compatibility. */
-template <class T, class U>
-inline bool operator == (const ::salloc::cached_allocator<T, U>&, const ::salloc::cached_allocator<T, U>&) throw()
-{
-    return true;
-}
-
-template <class T, class U, class W, class Q>
-inline bool operator == (const ::salloc::cached_allocator<T, U>&, const ::salloc::cached_allocator<W, Q>&) throw()
-{
-    return false;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 namespace std {
 
     template <class T, class TAlloc>

include/shared_allocator/shared_allocator.hpp

@@ -205,6 +205,13 @@ namespace salloc {
 
         /** \brief Empty copy constructor.
 
+        Does nothing. */
+        shared_allocator(const other&) throw()
+        {
+        }
+
+        /** \brief Empty copy constructor.
+
         Does nothing. */
         template <class U>
         shared_allocator(const shared_allocator<U>&) throw()
@@ -220,6 +227,19 @@ namespace salloc {
             return *this;
         }
 
+        /** Operator == for STL compatibility. */
+        inline bool operator == (const other&) throw()
+        {
+            return true;
+        }
+
+        /** Operator == for STL compatibility. */
+        template <class U>
+        inline bool operator == (const shared_allocator<U>&) throw()
+        {
+            return true;
+        }
+
         /** \brief Returns number of elements in allocated memory.
         
         \param _memory Pointer to allocated memory.
@@ -326,13 +346,6 @@ namespace salloc {
 
 } // END namespace salloc.
 
-/** Operator == for STL compatibility. */
-template <class T, class U>
-inline bool operator == (const ::salloc::shared_allocator<T>&, const ::salloc::shared_allocator<U>&) throw()
-{
-    return true;
-}
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 

include/shared_allocator/size_cached_allocator.hpp

@@ -62,6 +62,8 @@ namespace salloc {
     {
     protected:
 
+        typedef size_cached_allocator<T, TAlloc> ThisType;
+
         template <class U>
         using TSameAlloc = typename TAlloc::template rebind<U>::other;
 
@@ -119,9 +121,16 @@ namespace salloc {
 
         /** \brief Empty copy constructor.
 
+        Does nothing. */
+        size_cached_allocator(const ThisType&) throw()
+        {
+        }
+
+        /** \brief Empty copy constructor.
+
         Does nothing. */
         template <class U>
-        size_cached_allocator(const size_cached_allocator<U>&) throw()
+        size_cached_allocator(const U&) throw()
         {
         }
 
@@ -136,11 +145,24 @@ namespace salloc {
 
         Does nothing and returns reference to this allocator. */
         template <class U>
-        size_cached_allocator<T>& operator=(const size_cached_allocator<U>&)
+        size_cached_allocator<T>& operator = (const size_cached_allocator<U>&)
         {
             return *this;
         }
 
+        /** Operator == for STL compatibility. */
+        inline bool operator == (const ThisType&) throw()
+        {
+            return true;
+        }
+
+        /** Operator == for STL compatibility. */
+        template <class U, class W>
+        inline bool operator == (const size_cached_allocator<U, W>&) throw()
+        {
+            return false;
+        }
+
         ~size_cached_allocator()
         {
             for (auto pCache : m_memoryCache)
@@ -351,19 +373,6 @@ namespace salloc {
 
 } // END namespace salloc.
 
-/** Operator == for STL compatibility. */
-template <class T, class U>
-inline bool operator == (const ::salloc::size_cached_allocator<T, U>&, const ::salloc::size_cached_allocator<T, U>&) throw()
-{
-    return true;
-}
-
-template <class T, class U, class W, class Q>
-inline bool operator == (const ::salloc::size_cached_allocator<T, U>&, const ::salloc::size_cached_allocator<W, Q>&) throw()
-{
-    return false;
-}
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////