Update copyright years in libstdc++-v3/

[thirdparty/gcc.git] / libstdc++-v3 / include / ext / debug_allocator.h

diff --git a/libstdc++-v3/include/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h
index 6a4becb9b156a4346a94fb5275b16d94c55065a7..ffdfee6cc12cb079b3be6a7585f858e16917e62a 100644 (file)
--- a/libstdc++-v3/include/ext/debug_allocator.h
+++ b/libstdc++-v3/include/ext/debug_allocator.h
@@ -1,7 +1,6 @@
 // Allocators -*- C++ -*-
 
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009, 2010, 2011
-// Free Software Foundation, Inc.
+// Copyright (C) 2001-2014 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -44,6 +43,8 @@
 #define _DEBUG_ALLOCATOR_H 1
 
 #include <stdexcept>
+#include <bits/functexcept.h>
+#include <ext/alloc_traits.h>
 
 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
@@ -52,24 +53,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   using std::size_t;
 
   /**
-   *  @brief  A meta-allocator with debugging bits, as per [20.4].
+   *  @brief  A meta-allocator with debugging bits.
    *  @ingroup allocators
    *
-   *  This is precisely the allocator defined in the C++ Standard. 
-   *    - all allocation calls operator new
-   *    - all deallocation calls operator delete
+   *  This is precisely the allocator defined in the C++03 Standard.
    */
   template<typename _Alloc>
     class debug_allocator
     {
+      template<typename> friend class debug_allocator;
+
+      typedef __alloc_traits<_Alloc> _Traits;
+
     public:
-      typedef typename _Alloc::size_type               size_type;
-      typedef typename _Alloc::difference_type difference_type;
-      typedef typename _Alloc::pointer         pointer;
-      typedef typename _Alloc::const_pointer    const_pointer;
-      typedef typename _Alloc::reference               reference;
-      typedef typename _Alloc::const_reference  const_reference;
-      typedef typename _Alloc::value_type       value_type;
+      typedef typename _Traits::size_type              size_type;
+      typedef typename _Traits::difference_type        difference_type;
+      typedef typename _Traits::pointer        pointer;
+      typedef typename _Traits::const_pointer    const_pointer;
+      typedef typename _Traits::reference              reference;
+      typedef typename _Traits::const_reference  const_reference;
+      typedef typename _Traits::value_type       value_type;
+
+      template<typename _Up>
+       class rebind
+       {
+         typedef typename _Traits::template rebind<_Up>::other __other;
+
+       public:
+         typedef debug_allocator<__other> other;
+       };
 
     private:
       // _M_extra is the number of objects that correspond to the
@@ -78,13 +90,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       
       _Alloc                   _M_allocator;
 
-    public:
-      debug_allocator()
+      template<typename _Alloc2,
+              typename = typename _Alloc2::template rebind<value_type>::other>
+       struct __convertible
+       { };
+
+      template<typename _Alloc2>
+       struct __convertible<_Alloc2, _Alloc>
+       {
+         typedef void* __type;
+       };
+
+      size_type _S_extra()
       {
        const size_t __obj_size = sizeof(value_type);
-       _M_extra = (sizeof(size_type) + __obj_size - 1) / __obj_size; 
+       return (sizeof(size_type) + __obj_size - 1) / __obj_size; 
       }
-      
+
+    public:
+      debug_allocator() : _M_extra(_S_extra()) { }
+
+      template<typename _Alloc2>
+       debug_allocator(const debug_allocator<_Alloc2>& __a2,
+                       typename __convertible<_Alloc2>::__type = 0)
+       : _M_allocator(__a2._M_allocator), _M_extra(_S_extra()) { }
+
+      debug_allocator(const _Alloc& __a)
+      : _M_allocator(__a), _M_extra(_S_extra()) { }
+
       pointer
       allocate(size_type __n)
       {
@@ -106,21 +139,52 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       deallocate(pointer __p, size_type __n)
       {
+       using std::__throw_runtime_error;
        if (__p)
          {
            pointer __real_p = __p - _M_extra;
            if (*reinterpret_cast<size_type*>(__real_p) != __n)
-             {
-               throw std::runtime_error("debug_allocator::deallocate"
-                                        " wrong size");
-             }
+             __throw_runtime_error("debug_allocator::deallocate wrong size");
            _M_allocator.deallocate(__real_p, __n + _M_extra);
          }
        else
-         throw std::runtime_error("debug_allocator::deallocate null pointer");
+         __throw_runtime_error("debug_allocator::deallocate null pointer");
       }
+
+      void
+      construct(pointer __p, const value_type& __val)
+      { _Traits::construct(_M_allocator, __p, __val); }
+
+#if __cplusplus >= 201103L
+      template<typename _Tp, typename... _Args>
+       void
+       construct(_Tp* __p, _Args&&... __args)
+       {
+         _Traits::construct(_M_allocator, __p,
+                            std::forward<_Args>(__args)...);
+       }
+#endif
+
+      template<typename _Tp>
+       void
+       destroy(_Tp* __p)
+       { _Traits::destroy(_M_allocator, __p); }
+
+      size_type
+      max_size() const throw()
+      { return _Traits::max_size(_M_allocator) - _M_extra; }
+
+      friend bool
+      operator==(const debug_allocator& __lhs, const debug_allocator& __rhs)
+      { return __lhs._M_allocator == __rhs._M_allocator; }
     };
 
+  template<typename _Alloc>
+    inline bool
+    operator!=(const debug_allocator<_Alloc>& __lhs,
+              const debug_allocator<_Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace