atomic_base.h: Avoid including <stdbool.h>.

[gcc.git] / libstdc++-v3 / include / bits / vector.tcc

diff --git a/libstdc++-v3/include/bits/vector.tcc b/libstdc++-v3/include/bits/vector.tcc
index 85b514b561b00ce2ccacf72cdcfc22d71c43996f..19784c0ac2ecaeeabbe3cf6146114da036ebac6c 100644 (file)
--- a/libstdc++-v3/include/bits/vector.tcc
+++ b/libstdc++-v3/include/bits/vector.tcc
@@ -1,7 +1,6 @@
 // Vector implementation (out of line) -*- C++ -*-
 
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 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
@@ -85,7 +84,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        }
     }
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
   template<typename _Tp, typename _Alloc>
     template<typename... _Args>
       void
@@ -99,14 +98,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
            ++this->_M_impl._M_finish;
          }
        else
-         _M_insert_aux(end(), std::forward<_Args>(__args)...);
+         _M_emplace_back_aux(std::forward<_Args>(__args)...);
       }
 #endif
 
   template<typename _Tp, typename _Alloc>
     typename vector<_Tp, _Alloc>::iterator
     vector<_Tp, _Alloc>::
+#if __cplusplus >= 201103L
+    insert(const_iterator __position, const value_type& __x)
+#else
     insert(iterator __position, const value_type& __x)
+#endif
     {
       const size_type __n = __position - begin();
       if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
@@ -117,15 +120,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        }
       else
        {
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
+         const auto __pos = begin() + (__position - cbegin());
          if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
            {
              _Tp __x_copy = __x;
-             _M_insert_aux(__position, std::move(__x_copy));
+             _M_insert_aux(__pos, std::move(__x_copy));
            }
          else
-#endif
+           _M_insert_aux(__pos, __x);
+#else
            _M_insert_aux(__position, __x);
+#endif
        }
       return iterator(this->_M_impl._M_start + __n);
     }
@@ -133,7 +139,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp, typename _Alloc>
     typename vector<_Tp, _Alloc>::iterator
     vector<_Tp, _Alloc>::
-    erase(iterator __position)
+    _M_erase(iterator __position)
     {
       if (__position + 1 != end())
        _GLIBCXX_MOVE3(__position + 1, end(), __position);
@@ -145,11 +151,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp, typename _Alloc>
     typename vector<_Tp, _Alloc>::iterator
     vector<_Tp, _Alloc>::
-    erase(iterator __first, iterator __last)
+    _M_erase(iterator __first, iterator __last)
     {
-      if (__last != end())
-       _GLIBCXX_MOVE3(__last, end(), __first);
-      _M_erase_at_end(__first.base() + (end() - __last));
+      if (__first != __last)
+       {
+         if (__last != end())
+           _GLIBCXX_MOVE3(__last, end(), __first);
+         _M_erase_at_end(__first.base() + (end() - __last));
+       }
       return __first;
     }
 
@@ -160,7 +169,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
     {
       if (&__x != this)
        {
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
          if (_Alloc_traits::_S_propagate_on_copy_assign())
            {
              if (!_Alloc_traits::_S_always_equal()
@@ -171,6 +180,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                  _M_deallocate(this->_M_impl._M_start,
                                this->_M_impl._M_end_of_storage
                                - this->_M_impl._M_start);
+                 this->_M_impl._M_start = nullptr;
+                 this->_M_impl._M_finish = nullptr;
+                 this->_M_impl._M_end_of_storage = nullptr;
                }
              std::__alloc_on_copy(_M_get_Tp_allocator(),
                                   __x._M_get_Tp_allocator());
@@ -216,15 +228,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       if (__n > capacity())
        {
          vector __tmp(__n, __val, _M_get_Tp_allocator());
-         __tmp.swap(*this);
+         __tmp._M_impl._M_swap_data(this->_M_impl);
        }
       else if (__n > size())
        {
          std::fill(begin(), end(), __val);
-         std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
-                                       __n - size(), __val,
-                                       _M_get_Tp_allocator());
-         this->_M_impl._M_finish += __n - size();
+         this->_M_impl._M_finish =
+           std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+                                         __n - size(), __val,
+                                         _M_get_Tp_allocator());
        }
       else
         _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
@@ -282,12 +294,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
          }
       }
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
   template<typename _Tp, typename _Alloc>
     template<typename... _Args>
       typename vector<_Tp, _Alloc>::iterator
       vector<_Tp, _Alloc>::
-      emplace(iterator __position, _Args&&... __args)
+      emplace(const_iterator __position, _Args&&... __args)
       {
        const size_type __n = __position - begin();
        if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
@@ -298,7 +310,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
            ++this->_M_impl._M_finish;
          }
        else
-         _M_insert_aux(__position, std::forward<_Args>(__args)...);
+         _M_insert_aux(begin() + (__position - cbegin()),
+                       std::forward<_Args>(__args)...);
        return iterator(this->_M_impl._M_start + __n);
       }
 
@@ -320,13 +333,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                                   _GLIBCXX_MOVE(*(this->_M_impl._M_finish
                                                   - 1)));
          ++this->_M_impl._M_finish;
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus < 201103L
          _Tp __x_copy = __x;
 #endif
          _GLIBCXX_MOVE_BACKWARD3(__position.base(),
                                  this->_M_impl._M_finish - 2,
                                  this->_M_impl._M_finish - 1);
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus < 201103L
          *__position = __x_copy;
 #else
          *__position = _Tp(std::forward<_Args>(__args)...);
@@ -347,12 +360,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
              // taking the element by const lvalue ref (see 23.1/13).
              _Alloc_traits::construct(this->_M_impl,
                                       __new_start + __elems_before,
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
                                       std::forward<_Args>(__args)...);
 #else
                                       __x);
 #endif
-             __new_finish = 0;
+             __new_finish = pointer();
 
              __new_finish
                = std::__uninitialized_move_if_noexcept_a
@@ -387,6 +400,50 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        }
     }
 
+#if __cplusplus >= 201103L
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_emplace_back_aux(_Args&&... __args)
+      {
+       const size_type __len =
+         _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       __try
+         {
+           _Alloc_traits::construct(this->_M_impl, __new_start + size(),
+                                    std::forward<_Args>(__args)...);
+           __new_finish = pointer();
+
+           __new_finish
+             = std::__uninitialized_move_if_noexcept_a
+             (this->_M_impl._M_start, this->_M_impl._M_finish,
+              __new_start, _M_get_Tp_allocator());
+
+           ++__new_finish;
+         }
+       __catch(...)
+         {
+           if (!__new_finish)
+             _Alloc_traits::destroy(this->_M_impl, __new_start + size());
+           else
+             std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+           _M_deallocate(__new_start, __len);
+           __throw_exception_again;
+         }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+                     _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+                     this->_M_impl._M_end_of_storage
+                     - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+      }
+#endif
+
   template<typename _Tp, typename _Alloc>
     void
     vector<_Tp, _Alloc>::
@@ -414,11 +471,11 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                }
              else
                {
-                 std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
-                                               __n - __elems_after,
-                                               __x_copy,
-                                               _M_get_Tp_allocator());
-                 this->_M_impl._M_finish += __n - __elems_after;
+                 this->_M_impl._M_finish =
+                   std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+                                                 __n - __elems_after,
+                                                 __x_copy,
+                                                 _M_get_Tp_allocator());
                  std::__uninitialized_move_a(__position.base(), __old_finish,
                                              this->_M_impl._M_finish,
                                              _M_get_Tp_allocator());
@@ -439,7 +496,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                  std::__uninitialized_fill_n_a(__new_start + __elems_before,
                                                __n, __x,
                                                _M_get_Tp_allocator());
-                 __new_finish = 0;
+                 __new_finish = pointer();
 
                  __new_finish
                    = std::__uninitialized_move_if_noexcept_a
@@ -477,7 +534,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        }
     }
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
   template<typename _Tp, typename _Alloc>
     void
     vector<_Tp, _Alloc>::
@@ -488,9 +545,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
          if (size_type(this->_M_impl._M_end_of_storage
                        - this->_M_impl._M_finish) >= __n)
            {
-             std::__uninitialized_default_n_a(this->_M_impl._M_finish,
-                                              __n, _M_get_Tp_allocator());
-             this->_M_impl._M_finish += __n;
+             this->_M_impl._M_finish =
+               std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+                                                __n, _M_get_Tp_allocator());
            }
          else
            {
@@ -505,9 +562,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                    = std::__uninitialized_move_if_noexcept_a
                    (this->_M_impl._M_start, this->_M_impl._M_finish,
                     __new_start, _M_get_Tp_allocator());
-                 std::__uninitialized_default_n_a(__new_finish, __n,
-                                                  _M_get_Tp_allocator());
-                 __new_finish += __n;
+                 __new_finish =
+                   std::__uninitialized_default_n_a(__new_finish, __n,
+                                                    _M_get_Tp_allocator());
                }
              __catch(...)
                {
@@ -741,7 +798,28 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        }
     }
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+       _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+#if __cplusplus >= 201103L
   template<typename _Alloc>
     bool
     vector<bool, _Alloc>::
@@ -762,7 +840,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 _GLIBCXX_END_NAMESPACE_CONTAINER
 } // namespace std
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
@@ -771,7 +849,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Alloc>
     size_t
     hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>::
-    operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>& __b) const
+    operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>& __b) const noexcept
     {
       size_t __hash = 0;
       using _GLIBCXX_STD_C::_S_word_bit;
@@ -804,6 +882,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 
-#endif // __GXX_EXPERIMENTAL_CXX0X__
+#endif // C++11
 
 #endif /* _VECTOR_TCC */