vamp-build-and-test: DEPENDENCIES/generic/include/boost/container/deque.hpp comparison

comparison DEPENDENCIES/generic/include/boost/container/deque.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

author	Chris Cannam
date	Mon, 07 Sep 2015 11:12:49 +0100
parents	2665513ce2d3
children

comparison

equal deleted inserted replaced

-:793467b5e61c
+:c530137014c0
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
 // Software License, Version 1.0. (See accompanying file
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/libs/container for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
 #ifndef BOOST_CONTAINER_DEQUE_HPP
 #define BOOST_CONTAINER_DEQUE_HPP
-#if defined(_MSC_VER)
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
+// container
-#include <boost/container/detail/utilities.hpp>
-#include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/algorithms.hpp>
-#include <boost/container/detail/mpl.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/container_fwd.hpp>
+#include <boost/container/new_allocator.hpp> //new_allocator
 #include <boost/container/throw_exception.hpp>
+// container/detail
+#include <boost/container/detail/advanced_insert_int.hpp>
+#include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare
+#include <boost/container/detail/alloc_helpers.hpp>
+#include <boost/container/detail/copy_move_algo.hpp>
+#include <boost/container/detail/iterator.hpp>
+#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/container/detail/iterators.hpp>
+#include <boost/container/detail/min_max.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/container/detail/type_traits.hpp>
+// move
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/traits.hpp>
+#include <boost/move/utility_core.hpp>
+// move/detail
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
+#include <boost/move/detail/move_helpers.hpp>
+// other
+#include <boost/assert.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+// std
 #include <cstddef>
-#include <iterator>
-#include <boost/assert.hpp>
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <memory>
+#include <initializer_list>
-#include <algorithm>
+#endif
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/type_traits/has_trivial_copy.hpp>
-#include <boost/type_traits/has_trivial_assign.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-#include <boost/type_traits/has_nothrow_assign.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/move/iterator.hpp>
-#include <boost/move/detail/move_helpers.hpp>
-#include <boost/container/detail/advanced_insert_int.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
 namespace boost {
 namespace container {
-/// @cond
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Allocator = std::allocator<T> >
-#else
 template <class T, class Allocator>
-#endif
 class deque;
 template <class T>
 struct deque_value_traits
 {
 typedef T value_type;
-static const bool trivial_dctr = boost::has_trivial_destructor<value_type>::value;
+static const bool trivial_dctr = container_detail::is_trivially_destructible<value_type>::value;
 static const bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value;
-static const bool trivial_copy = has_trivial_copy<value_type>::value;
-static const bool nothrow_copy = has_nothrow_copy<value_type>::value;
-static const bool trivial_assign = has_trivial_assign<value_type>::value;
-//static const bool nothrow_assign = has_nothrow_assign<value_type>::value;
-static const bool nothrow_assign = false;
 };
 // Note: this function is simply a kludge to work around several compilers'
 //  bugs in handling constant expressions.
 template<class T>
 //    then [start.cur, finish.cur) are initialized objects, and
 //    the elements outside that range are uninitialized storage.  Otherwise,
 //    [start.cur, start.last) and [finish.first, finish.cur) are initialized
 //    objects, and [start.first, start.cur) and [finish.cur, finish.last)
 //    are uninitialized storage.
 //  [map, map + map_size) is a valid, non-empty range.
 //  [start.node, finish.node] is a valid range contained within
 //    [map, map + map_size).
-//  Allocator pointer in the range [map, map + map_size) points to an allocated node
+//  A pointer in the range [map, map + map_size) points to an allocated node
 //    if and only if the pointer is in the range [start.node, finish.node].
 template<class Pointer, bool IsConst>
 class deque_iterator
 {
 public:
-	typedef std::random_access_iterator_tag                                          iterator_category;
+typedef std::random_access_iterator_tag                                          iterator_category;
 typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
 typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
 typedef typename if_c
 < IsConst
 , typename boost::intrusive::pointer_traits<Pointer>::template
 static std::size_t s_buffer_size()
 { return deque_buf_size<value_type>::value; }
 typedef Pointer                                                                  val_alloc_ptr;
 typedef typename boost::intrusive::pointer_traits<Pointer>::
 template rebind_pointer<Pointer>::type                                        index_pointer;
 Pointer m_cur;
 Pointer m_first;
 Pointer m_last;
 index_pointer  m_node;
 Pointer get_cur()          const  {  return m_cur;  }
 Pointer get_first()        const  {  return m_first;  }
 Pointer get_last()         const  {  return m_last;  }
 index_pointer get_node()   const  {  return m_node;  }
-deque_iterator(val_alloc_ptr x, index_pointer y) BOOST_CONTAINER_NOEXCEPT
+deque_iterator(val_alloc_ptr x, index_pointer y) BOOST_NOEXCEPT_OR_NOTHROW
 : m_cur(x), m_first(*y), m_last(*y + s_buffer_size()), m_node(y)
 {}
-deque_iterator() BOOST_CONTAINER_NOEXCEPT
+deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
-: m_cur(), m_first(), m_last(), m_node()
+: m_cur(), m_first(), m_last(), m_node()  //Value initialization to achieve "null iterators" (N3644)
 {}
-deque_iterator(deque_iterator<Pointer, false> const& x) BOOST_CONTAINER_NOEXCEPT
+deque_iterator(deque_iterator<Pointer, false> const& x) BOOST_NOEXCEPT_OR_NOTHROW
 : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node())
 {}
-deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_CONTAINER_NOEXCEPT
+deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW
 : m_cur(cur), m_first(first), m_last(last), m_node(node)
 {}
-deque_iterator<Pointer, false> unconst() const BOOST_CONTAINER_NOEXCEPT
+deque_iterator<Pointer, false> unconst() const BOOST_NOEXCEPT_OR_NOTHROW
 {
 return deque_iterator<Pointer, false>(this->get_cur(), this->get_first(), this->get_last(), this->get_node());
 }
-reference operator*() const BOOST_CONTAINER_NOEXCEPT
+reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
 { return *this->m_cur; }
-pointer operator->() const BOOST_CONTAINER_NOEXCEPT
+pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->m_cur; }
-difference_type operator-(const deque_iterator& x) const BOOST_CONTAINER_NOEXCEPT
+difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW
 {
 if(!this->m_cur && !x.m_cur){
 return 0;
 }
 return difference_type(this->s_buffer_size()) * (this->m_node - x.m_node - 1) +
 (this->m_cur - this->m_first) + (x.m_last - x.m_cur);
 }
-deque_iterator& operator++() BOOST_CONTAINER_NOEXCEPT
+deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
 {
 ++this->m_cur;
 if (this->m_cur == this->m_last) {
 this->priv_set_node(this->m_node + 1);
 this->m_cur = this->m_first;
 }
 return *this;
 }
-deque_iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
+deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
 {
 deque_iterator tmp(*this);
 ++*this;
 return tmp;
 }
-deque_iterator& operator--() BOOST_CONTAINER_NOEXCEPT
+deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
 {
 if (this->m_cur == this->m_first) {
 this->priv_set_node(this->m_node - 1);
 this->m_cur = this->m_last;
 }
 --this->m_cur;
 return *this;
 }
-deque_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
+deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
 {
 deque_iterator tmp(*this);
 --*this;
 return tmp;
 }
-deque_iterator& operator+=(difference_type n) BOOST_CONTAINER_NOEXCEPT
+deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
 {
 difference_type offset = n + (this->m_cur - this->m_first);
 if (offset >= 0 && offset < difference_type(this->s_buffer_size()))
 this->m_cur += n;
 else {
 (offset - node_offset * difference_type(this->s_buffer_size()));
 }
 return *this;
 }
-deque_iterator operator+(difference_type n) const BOOST_CONTAINER_NOEXCEPT
+deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
 {  deque_iterator tmp(*this); return tmp += n;  }
-deque_iterator& operator-=(difference_type n) BOOST_CONTAINER_NOEXCEPT
+deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
 { return *this += -n; }
-deque_iterator operator-(difference_type n) const BOOST_CONTAINER_NOEXCEPT
+deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
 {  deque_iterator tmp(*this); return tmp -= n;  }
-reference operator[](difference_type n) const BOOST_CONTAINER_NOEXCEPT
+reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
 { return *(*this + n); }
-friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 { return l.m_cur == r.m_cur; }
-friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 { return l.m_cur != r.m_cur; }
-friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node);  }
-friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 { return r < l; }
-friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 { return !(r < l); }
-friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
 { return !(l < r); }
-void priv_set_node(index_pointer new_node) BOOST_CONTAINER_NOEXCEPT
+void priv_set_node(index_pointer new_node) BOOST_NOEXCEPT_OR_NOTHROW
 {
 this->m_node = new_node;
 this->m_first = *new_node;
 this->m_last = this->m_first + this->s_buffer_size();
 }
-friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_CONTAINER_NOEXCEPT
+friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
 {  return x += n;  }
 };
 }  //namespace container_detail {
 protected:
 typedef deque_value_traits<val_alloc_val>             traits_t;
 typedef ptr_alloc_t                                   map_allocator_type;
-static size_type s_buffer_size() BOOST_CONTAINER_NOEXCEPT
+static size_type s_buffer_size() BOOST_NOEXCEPT_OR_NOTHROW
 { return deque_buf_size<val_alloc_val>::value; }
 val_alloc_ptr priv_allocate_node()
 {  return this->alloc().allocate(s_buffer_size());  }
-void priv_deallocate_node(val_alloc_ptr p) BOOST_CONTAINER_NOEXCEPT
+void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
 {  this->alloc().deallocate(p, s_buffer_size());  }
 ptr_alloc_ptr priv_allocate_map(size_type n)
 { return this->ptr_alloc().allocate(n); }
-void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_CONTAINER_NOEXCEPT
+void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
 { this->ptr_alloc().deallocate(p, n); }
 typedef container_detail::deque_iterator<val_alloc_ptr, false> iterator;
 typedef container_detail::deque_iterator<val_alloc_ptr, true > const_iterator;
 }
 }
 private:
 deque_base(const deque_base&);
 protected:
-void swap_members(deque_base &x) BOOST_CONTAINER_NOEXCEPT
+void swap_members(deque_base &x) BOOST_NOEXCEPT_OR_NOTHROW
 {
-std::swap(this->members_.m_start, x.members_.m_start);
+::boost::adl_move_swap(this->members_.m_start, x.members_.m_start);
-std::swap(this->members_.m_finish, x.members_.m_finish);
+::boost::adl_move_swap(this->members_.m_finish, x.members_.m_finish);
-std::swap(this->members_.m_map, x.members_.m_map);
+::boost::adl_move_swap(this->members_.m_map, x.members_.m_map);
-std::swap(this->members_.m_map_size, x.members_.m_map_size);
+::boost::adl_move_swap(this->members_.m_map_size, x.members_.m_map_size);
 }
 void priv_initialize_map(size_type num_elements)
 {
 //      if(num_elements){
 this->members_.m_map_size = container_detail::max_value((size_type) InitialMapSize, num_nodes + 2);
 this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);
 ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
 ptr_alloc_ptr nfinish = nstart + num_nodes;
 BOOST_TRY {
 this->priv_create_nodes(nstart, nfinish);
 }
 BOOST_CATCH(...){
 this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
 //      }
 }
 void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
 {
-ptr_alloc_ptr cur;
+ptr_alloc_ptr cur = nstart;
 BOOST_TRY {
-for (cur = nstart; cur < nfinish; ++cur)
+for (; cur < nfinish; ++cur)
 *cur = this->priv_allocate_node();
 }
 BOOST_CATCH(...){
 this->priv_destroy_nodes(nstart, cur);
 BOOST_RETHROW
 }
 BOOST_CATCH_END
 }
-void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_CONTAINER_NOEXCEPT
+void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
 {
 for (ptr_alloc_ptr n = nstart; n < nfinish; ++n)
 this->priv_deallocate_node(*n);
 }
-void priv_clear_map() BOOST_CONTAINER_NOEXCEPT
+void priv_clear_map() BOOST_NOEXCEPT_OR_NOTHROW
 {
 if (this->members_.m_map) {
 this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1);
 this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
 this->members_.m_map = 0;
 val_alloc_size  m_map_size;
 iterator        m_start;
 iterator        m_finish;
 } members_;
-ptr_alloc_t &ptr_alloc() BOOST_CONTAINER_NOEXCEPT
+ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW
 {  return members_;  }
-const ptr_alloc_t &ptr_alloc() const BOOST_CONTAINER_NOEXCEPT
+const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
 {  return members_;  }
-allocator_type &alloc() BOOST_CONTAINER_NOEXCEPT
+allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
 {  return members_;  }
-const allocator_type &alloc() const BOOST_CONTAINER_NOEXCEPT
+const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
 {  return members_;  }
 };
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-//! Deque class
+#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
+//! A double-ended queue is a sequence that supports random access to elements, constant time insertion
+//! and removal of elements at the end of the sequence, and linear time insertion and removal of elements in the middle.
 //!
-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
+//! \tparam T The type of object that is stored in the deque
-template <class T, class Allocator = std::allocator<T> >
+//! \tparam Allocator The allocator used for all internal memory management
+template <class T, class Allocator = new_allocator<T> >
 #else
 template <class T, class Allocator>
 #endif
 class deque : protected deque_base<Allocator>
 {
-/// @cond
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 private:
 typedef deque_base<Allocator> Base;
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 public:
 //////////////////////////////////////////////
 //
 typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
 typedef Allocator                                                                   allocator_type;
 typedef BOOST_CONTAINER_IMPDEF(allocator_type)                                      stored_allocator_type;
 typedef BOOST_CONTAINER_IMPDEF(typename Base::iterator)                             iterator;
 typedef BOOST_CONTAINER_IMPDEF(typename Base::const_iterator)                       const_iterator;
-typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>)                     reverse_iterator;
+typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<iterator>)        reverse_iterator;
-typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>)               const_reverse_iterator;
+typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<const_iterator>)  const_reverse_iterator;
-/// @cond
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 private:                      // Internal typedefs
 BOOST_COPYABLE_AND_MOVABLE(deque)
 typedef typename Base::ptr_alloc_ptr index_pointer;
 static size_type s_buffer_size()
 { return Base::s_buffer_size(); }
 typedef allocator_traits<Allocator>                  allocator_traits_type;
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 public:
 //////////////////////////////////////////////
 //
 //          construct/copy/destroy
 //! <b>Effects</b>: Constructs a deque taking the allocator as parameter.
 //!
 //! <b>Throws</b>: Nothing
 //!
 //! <b>Complexity</b>: Constant.
-explicit deque(const allocator_type& a) BOOST_CONTAINER_NOEXCEPT
+explicit deque(const allocator_type& a) BOOST_NOEXCEPT_OR_NOTHROW
 : Base(a)
 {}
-//! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
+//! <b>Effects</b>: Constructs a deque
 //!   and inserts n value initialized values.
 //!
-//! <b>Throws</b>: If allocator_type's default constructor or copy constructor
+//! <b>Throws</b>: If allocator_type's default constructor
-//!   throws or T's default or copy constructor throws.
+//!   throws or T's value initialization throws.
 //!
 //! <b>Complexity</b>: Linear to n.
 explicit deque(size_type n)
 : Base(n, allocator_type())
 {
-container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy(this->alloc());
+container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
-proxy.uninitialized_copy_n_and_update(this->begin(), n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
 //deque_base will deallocate in case of exception...
 }
-//! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
+//! <b>Effects</b>: Constructs a deque
 //!   and inserts n default initialized values.
 //!
-//! <b>Throws</b>: If allocator_type's default constructor or copy constructor
+//! <b>Throws</b>: If allocator_type's default constructor
-//!   throws or T's default or copy constructor throws.
+//!   throws or T's default initialization or copy constructor throws.
 //!
 //! <b>Complexity</b>: Linear to n.
 //!
 //! <b>Note</b>: Non-standard extension
 deque(size_type n, default_init_t)
 : Base(n, allocator_type())
 {
-container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy(this->alloc());
+container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
-proxy.uninitialized_copy_n_and_update(this->begin(), n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+//deque_base will deallocate in case of exception...
+}
+//! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
+//!   and inserts n value initialized values.
+//!
+//! <b>Throws</b>: If allocator_type's default constructor
+//!   throws or T's value initialization throws.
+//!
+//! <b>Complexity</b>: Linear to n.
+explicit deque(size_type n, const allocator_type &a)
+: Base(n, a)
+{
+container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
+proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+//deque_base will deallocate in case of exception...
+}
+//! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
+//!   and inserts n default initialized values.
+//!
+//! <b>Throws</b>: If allocator_type's default constructor
+//!   throws or T's default initialization or copy constructor throws.
+//!
+//! <b>Complexity</b>: Linear to n.
+//!
+//! <b>Note</b>: Non-standard extension
+deque(size_type n, default_init_t, const allocator_type &a)
+: Base(n, a)
+{
+container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
+proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
 //deque_base will deallocate in case of exception...
 }
 //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
 //!   and inserts n copies of value.
 //!
-//! <b>Throws</b>: If allocator_type's default constructor or copy constructor
+//! <b>Throws</b>: If allocator_type's default constructor
-//!   throws or T's default or copy constructor throws.
+//!   throws or T's copy constructor throws.
 //!
 //! <b>Complexity</b>: Linear to n.
 deque(size_type n, const value_type& value,
 const allocator_type& a = allocator_type())
 : Base(n, a)
 { this->priv_fill_initialize(value); }
 //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
 //!   and inserts a copy of the range [first, last) in the deque.
 //!
-//! <b>Throws</b>: If allocator_type's default constructor or copy constructor
+//! <b>Throws</b>: If allocator_type's default constructor
-//!   throws or T's constructor taking an dereferenced InIt throws.
+//!   throws or T's constructor taking a dereferenced InIt throws.
 //!
 //! <b>Complexity</b>: Linear to the range [first, last).
 template <class InIt>
 deque(InIt first, InIt last, const allocator_type& a = allocator_type()
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 >::type * = 0
 #endif
 )
 : Base(a)
 {
-typedef typename std::iterator_traits<InIt>::iterator_category ItCat;
+this->priv_range_initialize(first, last);
-this->priv_range_initialize(first, last, ItCat());
+}
-}
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+//! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
+//!   and inserts a copy of the range [il.begin(), il.end()) in the deque.
+//!
+//! <b>Throws</b>: If allocator_type's default constructor
+//!   throws or T's constructor taking a dereferenced std::initializer_list iterator throws.
+//!
+//! <b>Complexity</b>: Linear to the range [il.begin(), il.end()).
+deque(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
+: Base(a)
+{
+this->priv_range_initialize(il.begin(), il.end());
+}
+#endif
 //! <b>Effects</b>: Copy constructs a deque.
 //!
 //! <b>Postcondition</b>: x == *this.
 //!
 boost::container::uninitialized_copy_alloc
 (this->alloc(), x.begin(), x.end(), this->members_.m_start);
 }
 }
-//! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
+//! <b>Effects</b>: Move constructor. Moves x's resources to *this.
 //!
 //! <b>Throws</b>: If allocator_type's copy constructor throws.
 //!
 //! <b>Complexity</b>: Constant.
 deque(BOOST_RV_REF(deque) x)
-:  Base(boost::move(static_cast<Base&>(x)))
+:  Base(BOOST_MOVE_BASE(Base, x))
 {  this->swap_members(x);   }
 //! <b>Effects</b>: Copy constructs a vector using the specified allocator.
 //!
 //! <b>Postcondition</b>: x == *this.
 (this->alloc(), x.begin(), x.end(), this->members_.m_start);
 }
 }
 //! <b>Effects</b>: Move constructor using the specified allocator.
-//!                 Moves mx's resources to *this if a == allocator_type().
+//!                 Moves x's resources to *this if a == allocator_type().
 //!                 Otherwise copies values from x to *this.
 //!
 //! <b>Throws</b>: If allocation or T's copy constructor throws.
 //!
-//! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise.
+//! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-deque(BOOST_RV_REF(deque) mx, const allocator_type &a)
+deque(BOOST_RV_REF(deque) x, const allocator_type &a)
 :  Base(a)
 {
-if(mx.alloc() == a){
+if(x.alloc() == a){
-this->swap_members(mx);
+this->swap_members(x);
 }
 else{
-if(mx.size()){
+if(x.size()){
-this->priv_initialize_map(mx.size());
+this->priv_initialize_map(x.size());
 boost::container::uninitialized_copy_alloc
-(this->alloc(), mx.begin(), mx.end(), this->members_.m_start);
+( this->alloc(), boost::make_move_iterator(x.begin())
+, boost::make_move_iterator(x.end()), this->members_.m_start);
 }
 }
 }
 //! <b>Effects</b>: Destroys the deque. All stored values are destroyed
 //!   and used memory is deallocated.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of elements.
-~deque() BOOST_CONTAINER_NOEXCEPT
+~deque() BOOST_NOEXCEPT_OR_NOTHROW
 {
 this->priv_destroy_range(this->members_.m_start, this->members_.m_finish);
 }
 //! <b>Effects</b>: Makes *this contain the same elements as x.
 this->assign(x.cbegin(), x.cend());
 }
 return *this;
 }
-//! <b>Effects</b>: Move assignment. All mx's values are transferred to *this.
+//! <b>Effects</b>: Move assignment. All x's values are transferred to *this.
 //!
-//! <b>Postcondition</b>: x.empty(). *this contains a the elements x had
+//! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment
-//!   before the function.
+//!   is false and (allocation throws or value_type's move constructor throws)
 //!
-//! <b>Throws</b>: If allocator_type's copy constructor throws.
+//! <b>Complexity</b>: Constant if allocator_traits_type::
-//!
+//!   propagate_on_container_move_assignment is true or
-//! <b>Complexity</b>: Linear.
+//!   this->get>allocator() == x.get_allocator(). Linear otherwise.
 deque& operator= (BOOST_RV_REF(deque) x)
-{
+BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
-if (&x != this){
+|| allocator_traits_type::is_always_equal::value)
-allocator_type &this_alloc = this->alloc();
+{
-allocator_type &x_alloc    = x.alloc();
+BOOST_ASSERT(this != &x);
-//If allocators are equal we can just swap pointers
+allocator_type &this_alloc = this->alloc();
-if(this_alloc == x_alloc){
+allocator_type &x_alloc    = x.alloc();
-//Destroy objects but retain memory in case x reuses it in the future
+const bool propagate_alloc = allocator_traits_type::
-this->clear();
+propagate_on_container_move_assignment::value;
-this->swap_members(x);
+container_detail::bool_<propagate_alloc> flag;
-//Move allocator if needed
+const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
-container_detail::bool_<allocator_traits_type::
+//Resources can be transferred if both allocators are
-propagate_on_container_move_assignment::value> flag;
+//going to be equal after this function (either propagated or already equal)
-container_detail::move_alloc(this_alloc, x_alloc, flag);
+if(propagate_alloc || allocators_equal){
-container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+//Destroy objects but retain memory in case x reuses it in the future
-}
+this->clear();
-//If unequal allocators, then do a one by one move
+//Move allocator if needed
-else{
+container_detail::move_alloc(this_alloc, x_alloc, flag);
-this->assign( boost::make_move_iterator(x.begin())
+container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
-, boost::make_move_iterator(x.end()));
+//Nothrow swap
-}
+this->swap_members(x);
+}
+//Else do a one by one move
+else{
+this->assign( boost::make_move_iterator(x.begin())
+, boost::make_move_iterator(x.end()));
 }
 return *this;
 }
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+//! <b>Effects</b>: Makes *this contain the same elements as il.
+//!
+//! <b>Postcondition</b>: this->size() == il.size(). *this contains a copy
+//! of each of x's elements.
+//!
+//! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
+//!
+//! <b>Complexity</b>: Linear to the number of elements in il.
+deque& operator=(std::initializer_list<value_type> il)
+{
+this->assign(il.begin(), il.end());
+return *this;
+}
+#endif
 //! <b>Effects</b>: Assigns the n copies of val to *this.
 //!
 //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
 //!
 < !container_detail::is_convertible<FwdIt, size_type>::value
 && !container_detail::is_input_iterator<FwdIt>::value
 >::type * = 0
 )
 {
-const size_type len = std::distance(first, last);
+const size_type len = boost::container::iterator_distance(first, last);
 if (len > size()) {
 FwdIt mid = first;
-std::advance(mid, this->size());
+boost::container::iterator_advance(mid, this->size());
 boost::container::copy(first, mid, begin());
 this->insert(this->cend(), mid, last);
 }
 else{
 this->erase(boost::container::copy(first, last, this->begin()), cend());
 }
 }
 #endif
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+//! <b>Effects</b>: Assigns the the range [il.begin(), il.end()) to *this.
+//!
+//! <b>Throws</b>: If memory allocation throws or
+//!   T's constructor from dereferencing std::initializer_list iterator throws.
+//!
+//! <b>Complexity</b>: Linear to il.size().
+void assign(std::initializer_list<value_type> il)
+{   this->assign(il.begin(), il.end());   }
+#endif
 //! <b>Effects</b>: Returns a copy of the internal allocator.
 //!
 //! <b>Throws</b>: If allocator's copy constructor throws.
 //!
 //! <b>Complexity</b>: Constant.
-allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
+allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
 { return Base::alloc(); }
 //! <b>Effects</b>: Returns a reference to the internal allocator.
 //!
 //! <b>Throws</b>: Nothing
 //!
 //! <b>Complexity</b>: Constant.
 //!
 //! <b>Note</b>: Non-standard extension.
-const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
+const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
 {  return Base::alloc(); }
 //////////////////////////////////////////////
 //
 //                iterators
 //! <b>Throws</b>: Nothing
 //!
 //! <b>Complexity</b>: Constant.
 //!
 //! <b>Note</b>: Non-standard extension.
-stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
+stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
 {  return Base::alloc(); }
 //! <b>Effects</b>: Returns an iterator to the first element contained in the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-iterator begin() BOOST_CONTAINER_NOEXCEPT
+iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_start; }
 //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_iterator begin() const BOOST_CONTAINER_NOEXCEPT
+const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_start; }
 //! <b>Effects</b>: Returns an iterator to the end of the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-iterator end() BOOST_CONTAINER_NOEXCEPT
+iterator end() BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_finish; }
 //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_iterator end() const BOOST_CONTAINER_NOEXCEPT
+const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_finish; }
 //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT
+reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
 { return reverse_iterator(this->members_.m_finish); }
 //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT
+const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
 { return const_reverse_iterator(this->members_.m_finish); }
 //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT
+reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
 { return reverse_iterator(this->members_.m_start); }
 //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT
+const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
 { return const_reverse_iterator(this->members_.m_start); }
 //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT
+const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_start; }
 //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_iterator cend() const BOOST_CONTAINER_NOEXCEPT
+const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_finish; }
 //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT
+const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
 { return const_reverse_iterator(this->members_.m_finish); }
 //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
 //! of the reversed deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT
+const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
 { return const_reverse_iterator(this->members_.m_start); }
 //////////////////////////////////////////////
 //
 //                capacity
 //! <b>Effects</b>: Returns true if the deque contains no elements.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-bool empty() const BOOST_CONTAINER_NOEXCEPT
+bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_finish == this->members_.m_start; }
 //! <b>Effects</b>: Returns the number of the elements contained in the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-size_type size() const BOOST_CONTAINER_NOEXCEPT
+size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_finish - this->members_.m_start; }
 //! <b>Effects</b>: Returns the largest possible size of the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-size_type max_size() const BOOST_CONTAINER_NOEXCEPT
+size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
 { return allocator_traits_type::max_size(this->alloc()); }
 //! <b>Effects</b>: Inserts or erases elements at the end such that
 //!   the size becomes n. New elements are value initialized.
 //!
 const size_type len = size();
 if (new_size < len)
 this->priv_erase_last_n(len - new_size);
 else{
 const size_type n = new_size - this->size();
-container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy(this->alloc());
+container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
 priv_insert_back_aux_impl(n, proxy);
 }
 }
 //! <b>Effects</b>: Inserts or erases elements at the end such that
 const size_type len = size();
 if (new_size < len)
 this->priv_erase_last_n(len - new_size);
 else{
 const size_type n = new_size - this->size();
-container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy(this->alloc());
+container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
 priv_insert_back_aux_impl(n, proxy);
 }
 }
 //! <b>Effects</b>: Inserts or erases elements at the end such that
 //!   element of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-reference front() BOOST_CONTAINER_NOEXCEPT
+reference front() BOOST_NOEXCEPT_OR_NOTHROW
 { return *this->members_.m_start; }
 //! <b>Requires</b>: !empty()
 //!
 //! <b>Effects</b>: Returns a const reference to the first element
 //!   from the beginning of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reference front() const BOOST_CONTAINER_NOEXCEPT
+const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
 { return *this->members_.m_start; }
 //! <b>Requires</b>: !empty()
 //!
 //! <b>Effects</b>: Returns a reference to the last
 //!   element of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-reference back() BOOST_CONTAINER_NOEXCEPT
+reference back() BOOST_NOEXCEPT_OR_NOTHROW
 {  return *(end()-1); }
 //! <b>Requires</b>: !empty()
 //!
 //! <b>Effects</b>: Returns a const reference to the last
 //!   element of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reference back() const BOOST_CONTAINER_NOEXCEPT
+const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW
 {  return *(cend()-1);  }
 //! <b>Requires</b>: size() > n.
 //!
 //! <b>Effects</b>: Returns a reference to the nth element
 //!   from the beginning of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-reference operator[](size_type n) BOOST_CONTAINER_NOEXCEPT
+reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_start[difference_type(n)]; }
 //! <b>Requires</b>: size() > n.
 //!
 //! <b>Effects</b>: Returns a const reference to the nth element
 //!   from the beginning of the container.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
-const_reference operator[](size_type n) const BOOST_CONTAINER_NOEXCEPT
+const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
 { return this->members_.m_start[difference_type(n)]; }
+//! <b>Requires</b>: size() >= n.
+//!
+//! <b>Effects</b>: Returns an iterator to the nth element
+//!   from the beginning of the container. Returns end()
+//!   if n == size().
+//!
+//! <b>Throws</b>: Nothing.
+//!
+//! <b>Complexity</b>: Constant.
+//!
+//! <b>Note</b>: Non-standard extension
+iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+{
+BOOST_ASSERT(this->size() >= n);
+return iterator(this->begin()+n);
+}
+//! <b>Requires</b>: size() >= n.
+//!
+//! <b>Effects</b>: Returns a const_iterator to the nth element
+//!   from the beginning of the container. Returns end()
+//!   if n == size().
+//!
+//! <b>Throws</b>: Nothing.
+//!
+//! <b>Complexity</b>: Constant.
+//!
+//! <b>Note</b>: Non-standard extension
+const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+{
+BOOST_ASSERT(this->size() >= n);
+return const_iterator(this->cbegin()+n);
+}
+//! <b>Requires</b>: size() >= n.
+//!
+//! <b>Effects</b>: Returns an iterator to the nth element
+//!   from the beginning of the container. Returns end()
+//!   if n == size().
+//!
+//! <b>Throws</b>: Nothing.
+//!
+//! <b>Complexity</b>: Constant.
+//!
+//! <b>Note</b>: Non-standard extension
+size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+{  return this->priv_index_of(p);  }
+//! <b>Requires</b>: begin() <= p <= end().
+//!
+//! <b>Effects</b>: Returns the index of the element pointed by p
+//!   and size() if p == end().
+//!
+//! <b>Throws</b>: Nothing.
+//!
+//! <b>Complexity</b>: Constant.
+//!
+//! <b>Note</b>: Non-standard extension
+size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+{  return this->priv_index_of(p);  }
 //! <b>Requires</b>: size() > n.
 //!
 //! <b>Effects</b>: Returns a reference to the nth element
 //!   from the beginning of the container.
 //
 //                modifiers
 //
 //////////////////////////////////////////////
-#if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! <b>Effects</b>: Inserts an object of type T constructed with
 //!   std::forward<Args>(args)... in the beginning of the deque.
 //!
 //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws.
 //!
 //! <b>Complexity</b>: Amortized constant time
 template <class... Args>
-void emplace_front(Args&&... args)
+void emplace_front(BOOST_FWD_REF(Args)... args)
 {
 if(this->priv_push_front_simple_available()){
 allocator_traits_type::construct
 ( this->alloc()
 , this->priv_push_front_simple_pos()
 , boost::forward<Args>(args)...);
 this->priv_push_front_simple_commit();
 }
 else{
-typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type;
+typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
-this->priv_insert_front_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...));
+this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...));
 }
 }
 //! <b>Effects</b>: Inserts an object of type T constructed with
 //!   std::forward<Args>(args)... in the end of the deque.
 //!
 //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws.
 //!
 //! <b>Complexity</b>: Amortized constant time
 template <class... Args>
-void emplace_back(Args&&... args)
+void emplace_back(BOOST_FWD_REF(Args)... args)
 {
 if(this->priv_push_back_simple_available()){
 allocator_traits_type::construct
 ( this->alloc()
 , this->priv_push_back_simple_pos()
 , boost::forward<Args>(args)...);
 this->priv_push_back_simple_commit();
 }
 else{
-typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type;
+typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
-this->priv_insert_back_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...));
+this->priv_insert_back_aux_impl(1, type(boost::forward<Args>(args)...));
 }
 }
-//! <b>Requires</b>: position must be a valid iterator of *this.
+//! <b>Requires</b>: p must be a valid iterator of *this.
 //!
 //! <b>Effects</b>: Inserts an object of type T constructed with
-//!   std::forward<Args>(args)... before position
+//!   std::forward<Args>(args)... before p
 //!
 //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws.
 //!
-//! <b>Complexity</b>: If position is end(), amortized constant time
+//! <b>Complexity</b>: If p is end(), amortized constant time
 //!   Linear time otherwise.
 template <class... Args>
-iterator emplace(const_iterator p, Args&&... args)
+iterator emplace(const_iterator p, BOOST_FWD_REF(Args)... args)
 {
 if(p == this->cbegin()){
 this->emplace_front(boost::forward<Args>(args)...);
 return this->begin();
 }
 this->emplace_back(boost::forward<Args>(args)...);
 return (this->end()-1);
 }
 else{
 typedef container_detail::insert_emplace_proxy<Allocator, iterator, Args...> type;
-return this->priv_insert_aux_impl(p, 1, type(this->alloc(), boost::forward<Args>(args)...));
+return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
 }
 }
-#else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+#else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-//advanced_insert_int.hpp includes all necessary preprocessor machinery...
+#define BOOST_CONTAINER_DEQUE_EMPLACE_CODE(N) \
-#define BOOST_PP_LOCAL_MACRO(n)                                                           \
+BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
-BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >  )  \
+void emplace_front(BOOST_MOVE_UREF##N)\
-void emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                    \
+{\
-{                                                                                         \
+if(priv_push_front_simple_available()){\
-if(priv_push_front_simple_available()){                                                \
+allocator_traits_type::construct\
-allocator_traits_type::construct                                                    \
+( this->alloc(), this->priv_push_front_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-( this->alloc()                                                                  \
+priv_push_front_simple_commit();\
-, this->priv_push_front_simple_pos()                                             \
+}\
-BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));               \
+else{\
-priv_push_front_simple_commit();                                                    \
+typedef container_detail::insert_nonmovable_emplace_proxy##N\
-}                                                                                      \
+<Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
-else{                                                                                  \
+priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\
-container_detail::BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, n)             \
+}\
-<Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy               \
+}\
-(this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));  \
+\
-priv_insert_front_aux_impl(1, proxy);                                               \
+BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
-}                                                                                      \
+void emplace_back(BOOST_MOVE_UREF##N)\
-}                                                                                         \
+{\
-\
+if(priv_push_back_simple_available()){\
-BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)    \
+allocator_traits_type::construct\
-void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                     \
+( this->alloc(), this->priv_push_back_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-{                                                                                         \
+priv_push_back_simple_commit();\
-if(priv_push_back_simple_available()){                                                 \
+}\
-allocator_traits_type::construct                                                    \
+else{\
-( this->alloc()                                                                  \
+typedef container_detail::insert_nonmovable_emplace_proxy##N\
-, this->priv_push_back_simple_pos()                                              \
+<Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
-BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));               \
+priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\
-priv_push_back_simple_commit();                                                     \
+}\
-}                                                                                      \
+}\
-else{                                                                                  \
+\
-container_detail::BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, n)             \
+BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
-<Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy               \
+iterator emplace(const_iterator p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-(this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));  \
+{\
-priv_insert_back_aux_impl(1, proxy);                                                \
+if(p == this->cbegin()){\
-}                                                                                      \
+this->emplace_front(BOOST_MOVE_FWD##N);\
-}                                                                                         \
+return this->begin();\
-\
+}\
-BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)    \
+else if(p == cend()){\
-iterator emplace(const_iterator p                                                         \
+this->emplace_back(BOOST_MOVE_FWD##N);\
-BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))             \
+return (--this->end());\
-{                                                                                         \
+}\
-if(p == this->cbegin()){                                                               \
+else{\
-this->emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));         \
+typedef container_detail::insert_emplace_proxy_arg##N\
-return this->begin();                                                               \
+<Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
-}                                                                                      \
+return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
-else if(p == cend()){                                                                  \
+}\
-this->emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));          \
+}
-return (this->end()-1);                                                             \
+//
-}                                                                                      \
+BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEQUE_EMPLACE_CODE)
-else{                                                                                  \
+#undef BOOST_CONTAINER_DEQUE_EMPLACE_CODE
-container_detail::BOOST_PP_CAT(insert_emplace_proxy_arg, n)                         \
-<Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy                  \
+#endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-(this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));  \
-return this->priv_insert_aux_impl(p, 1, proxy);                                     \
-}                                                                                      \
-}                                                                                         \
-//!
-#define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
-#include BOOST_PP_LOCAL_ITERATE()
-#endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! <b>Effects</b>: Inserts a copy of x at the front of the deque.
 //!
 //! <b>Throws</b>: If memory allocation throws or
 //!
 //! <b>Complexity</b>: Amortized constant time.
 void push_front(const T &x);
 //! <b>Effects</b>: Constructs a new element in the front of the deque
-//!   and moves the resources of mx to this new element.
+//!   and moves the resources of x to this new element.
 //!
 //! <b>Throws</b>: If memory allocation throws.
 //!
 //! <b>Complexity</b>: Amortized constant time.
 void push_front(T &&x);
 //!
 //! <b>Complexity</b>: Amortized constant time.
 void push_back(const T &x);
 //! <b>Effects</b>: Constructs a new element in the end of the deque
-//!   and moves the resources of mx to this new element.
+//!   and moves the resources of x to this new element.
 //!
 //! <b>Throws</b>: If memory allocation throws.
 //!
 //! <b>Complexity</b>: Amortized constant time.
 void push_back(T &&x);
 BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
 #endif
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-//! <b>Requires</b>: position must be a valid iterator of *this.
+//! <b>Requires</b>: p must be a valid iterator of *this.
 //!
-//! <b>Effects</b>: Insert a copy of x before position.
+//! <b>Effects</b>: Insert a copy of x before p.
 //!
 //! <b>Returns</b>: an iterator to the inserted element.
 //!
 //! <b>Throws</b>: If memory allocation throws or x's copy constructor throws.
 //!
-//! <b>Complexity</b>: If position is end(), amortized constant time
+//! <b>Complexity</b>: If p is end(), amortized constant time
 //!   Linear time otherwise.
-iterator insert(const_iterator position, const T &x);
+iterator insert(const_iterator p, const T &x);
-//! <b>Requires</b>: position must be a valid iterator of *this.
+//! <b>Requires</b>: p must be a valid iterator of *this.
 //!
-//! <b>Effects</b>: Insert a new element before position with mx's resources.
+//! <b>Effects</b>: Insert a new element before p with x's resources.
 //!
 //! <b>Returns</b>: an iterator to the inserted element.
 //!
 //! <b>Throws</b>: If memory allocation throws.
 //!
-//! <b>Complexity</b>: If position is end(), amortized constant time
+//! <b>Complexity</b>: If p is end(), amortized constant time
 //!   Linear time otherwise.
-iterator insert(const_iterator position, T &&x);
+iterator insert(const_iterator p, T &&x);
 #else
 BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator, const_iterator)
 #endif
 //! <b>Requires</b>: pos must be a valid iterator of *this.
 //! <b>Returns</b>: an iterator to the first inserted element or pos if first == last.
 //!
 //! <b>Throws</b>: If memory allocation throws, T's constructor from a
 //!   dereferenced InIt throws or T's copy constructor throws.
 //!
-//! <b>Complexity</b>: Linear to std::distance [first, last).
+//! <b>Complexity</b>: Linear to distance [first, last).
 template <class InIt>
 iterator insert(const_iterator pos, InIt first, InIt last
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 , typename container_detail::enable_if_c
 < !container_detail::is_convertible<InIt, size_type>::value
 ++it;
 }
 it -= n;
 return it;
 }
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+//! <b>Requires</b>: pos must be a valid iterator of *this.
+//!
+//! <b>Effects</b>: Insert a copy of the [il.begin(), il.end()) range before pos.
+//!
+//! <b>Returns</b>: an iterator to the first inserted element or pos if il.begin() == il.end().
+//!
+//! <b>Throws</b>: If memory allocation throws, T's constructor from a
+//!   dereferenced std::initializer_list throws or T's copy constructor throws.
+//!
+//! <b>Complexity</b>: Linear to distance [il.begin(), il.end()).
+iterator insert(const_iterator pos, std::initializer_list<value_type> il)
+{   return insert(pos, il.begin(), il.end());   }
+#endif
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 template <class FwdIt>
 iterator insert(const_iterator p, FwdIt first, FwdIt last
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 && !container_detail::is_input_iterator<FwdIt>::value
 >::type * = 0
 #endif
 )
 {
-container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(this->alloc(), first);
+container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(first);
-return priv_insert_aux_impl(p, (size_type)std::distance(first, last), proxy);
+return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy);
 }
 #endif
 //! <b>Effects</b>: Removes the first element from the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant time.
-void pop_front() BOOST_CONTAINER_NOEXCEPT
+void pop_front() BOOST_NOEXCEPT_OR_NOTHROW
 {
 if (this->members_.m_start.m_cur != this->members_.m_start.m_last - 1) {
 allocator_traits_type::destroy
 ( this->alloc()
 , container_detail::to_raw_pointer(this->members_.m_start.m_cur)
 //! <b>Effects</b>: Removes the last element from the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant time.
-void pop_back() BOOST_CONTAINER_NOEXCEPT
+void pop_back() BOOST_NOEXCEPT_OR_NOTHROW
 {
 if (this->members_.m_finish.m_cur != this->members_.m_finish.m_first) {
 --this->members_.m_finish.m_cur;
 allocator_traits_type::destroy
 ( this->alloc()
 }
 else
 this->priv_pop_back_aux();
 }
-//! <b>Effects</b>: Erases the element at position pos.
+//! <b>Effects</b>: Erases the element at p.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the elements between pos and the
 //!   last element (if pos is near the end) or the first element
 //!   if(pos is near the beginning).
 //!   Constant if pos is the first or the last element.
-iterator erase(const_iterator pos) BOOST_CONTAINER_NOEXCEPT
+iterator erase(const_iterator pos) BOOST_NOEXCEPT_OR_NOTHROW
 {
 iterator next = pos.unconst();
 ++next;
 size_type index = pos - this->members_.m_start;
 if (index < (this->size()/2)) {
-boost::move_backward(this->begin(), pos.unconst(), next);
+boost::container::move_backward(this->begin(), pos.unconst(), next);
 pop_front();
 }
 else {
-boost::move(next, this->end(), pos.unconst());
+boost::container::move(next, this->end(), pos.unconst());
 pop_back();
 }
 return this->members_.m_start + index;
 }
 //!
 //! <b>Complexity</b>: Linear to the distance between first and
 //!   last plus the elements between pos and the
 //!   last element (if pos is near the end) or the first element
 //!   if(pos is near the beginning).
-iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT
+iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW
 {
 if (first == this->members_.m_start && last == this->members_.m_finish) {
 this->clear();
 return this->members_.m_finish;
 }
 else {
 const size_type n = static_cast<size_type>(last - first);
 const size_type elems_before = static_cast<size_type>(first - this->members_.m_start);
 if (elems_before < (this->size() - n) - elems_before) {
-boost::move_backward(begin(), first.unconst(), last.unconst());
+boost::container::move_backward(begin(), first.unconst(), last.unconst());
 iterator new_start = this->members_.m_start + n;
 if(!Base::traits_t::trivial_dctr_after_move)
 this->priv_destroy_range(this->members_.m_start, new_start);
 this->priv_destroy_nodes(this->members_.m_start.m_node, new_start.m_node);
 this->members_.m_start = new_start;
 }
 else {
-boost::move(last.unconst(), end(), first.unconst());
+boost::container::move(last.unconst(), end(), first.unconst());
 iterator new_finish = this->members_.m_finish - n;
 if(!Base::traits_t::trivial_dctr_after_move)
 this->priv_destroy_range(new_finish, this->members_.m_finish);
 this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1);
 this->members_.m_finish = new_finish;
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Constant.
 void swap(deque &x)
+BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_swap::value
+|| allocator_traits_type::is_always_equal::value)
 {
 this->swap_members(x);
 container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
 container_detail::swap_alloc(this->alloc(), x.alloc(), flag);
 container_detail::swap_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
 //! <b>Effects</b>: Erases all the elements of the deque.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of elements in the deque.
-void clear() BOOST_CONTAINER_NOEXCEPT
+void clear() BOOST_NOEXCEPT_OR_NOTHROW
 {
 for (index_pointer node = this->members_.m_start.m_node + 1;
 node < this->members_.m_finish.m_node;
 ++node) {
 this->priv_destroy_range(*node, *node + this->s_buffer_size());
 this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_finish.m_cur);
 this->members_.m_finish = this->members_.m_start;
 }
-/// @cond
+//! <b>Effects</b>: Returns true if x and y are equal
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator==(const deque& x, const deque& y)
+{  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
+//! <b>Effects</b>: Returns true if x and y are unequal
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator!=(const deque& x, const deque& y)
+{  return !(x == y); }
+//! <b>Effects</b>: Returns true if x is less than y
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator<(const deque& x, const deque& y)
+{  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
+//! <b>Effects</b>: Returns true if x is greater than y
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator>(const deque& x, const deque& y)
+{  return y < x;  }
+//! <b>Effects</b>: Returns true if x is equal or less than y
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator<=(const deque& x, const deque& y)
+{  return !(y < x);  }
+//! <b>Effects</b>: Returns true if x is equal or greater than y
+//!
+//! <b>Complexity</b>: Linear to the number of elements in the container.
+friend bool operator>=(const deque& x, const deque& y)
+{  return !(x < y);  }
+//! <b>Effects</b>: x.swap(y)
+//!
+//! <b>Complexity</b>: Constant.
+friend void swap(deque& x, deque& y)
+{  x.swap(y);  }
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 private:
+size_type priv_index_of(const_iterator p) const
+{
+BOOST_ASSERT(this->cbegin() <= p);
+BOOST_ASSERT(p <= this->cend());
+return static_cast<size_type>(p - this->cbegin());
+}
 void priv_erase_last_n(size_type n)
 {
 if(n == this->size()) {
 this->clear();
 void priv_range_check(size_type n) const
 {  if (n >= this->size())  throw_out_of_range("deque::at out of range");   }
 template <class U>
-iterator priv_insert(const_iterator position, BOOST_FWD_REF(U) x)
+iterator priv_insert(const_iterator p, BOOST_FWD_REF(U) x)
 {
-if (position == cbegin()){
+if (p == cbegin()){
 this->push_front(::boost::forward<U>(x));
 return begin();
 }
-else if (position == cend()){
+else if (p == cend()){
 this->push_back(::boost::forward<U>(x));
 return --end();
 }
 else {
 return priv_insert_aux_impl
-(position, (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x)));
+( p, (size_type)1
+, container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
 }
 }
 template <class U>
 void priv_push_front(BOOST_FWD_REF(U) x)
 ( this->alloc(), this->priv_push_front_simple_pos(), ::boost::forward<U>(x));
 this->priv_push_front_simple_commit();
 }
 else{
 priv_insert_aux_impl
-(this->cbegin(), (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x)));
+( this->cbegin(), (size_type)1
+, container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
 }
 }
 template <class U>
 void priv_push_back(BOOST_FWD_REF(U) x)
 ( this->alloc(), this->priv_push_back_simple_pos(), ::boost::forward<U>(x));
 this->priv_push_back_simple_commit();
 }
 else{
 priv_insert_aux_impl
-(this->cend(), (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x)));
+( this->cend(), (size_type)1
-container_detail::insert_copy_proxy<Allocator, iterator> proxy(this->alloc(), x);
+, container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
 }
 }
 bool priv_push_back_simple_available() const
 {
 void priv_push_front_simple_commit()
 {  --this->members_.m_start.m_cur;   }
 void priv_destroy_range(iterator p, iterator p2)
 {
-for(;p != p2; ++p){
+if(!Base::traits_t::trivial_dctr){
-allocator_traits_type::destroy
+for(;p != p2; ++p){
-( this->alloc()
+allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p));
-, container_detail::to_raw_pointer(&*p)
+}
-);
 }
 }
 void priv_destroy_range(pointer p, pointer p2)
 {
-for(;p != p2; ++p){
+if(!Base::traits_t::trivial_dctr){
-allocator_traits_type::destroy
+for(;p != p2; ++p){
-( this->alloc()
+allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p));
-, container_detail::to_raw_pointer(&*p)
+}
-);
 }
 }
 template<class InsertProxy>
-iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy interf)
+iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy)
 {
 iterator pos(p.unconst());
 const size_type pos_n = p - this->cbegin();
 if(!this->members_.m_map){
 this->priv_initialize_map(0);
 const size_type length = this->size();
 if (elemsbefore < length / 2) {
 const iterator new_start = this->priv_reserve_elements_at_front(n);
 const iterator old_start = this->members_.m_start;
 if(!elemsbefore){
-interf.uninitialized_copy_n_and_update(new_start, n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
 this->members_.m_start = new_start;
 }
 else{
 pos = this->members_.m_start + elemsbefore;
 if (elemsbefore >= n) {
 const iterator start_n = this->members_.m_start + n;
 ::boost::container::uninitialized_move_alloc
 (this->alloc(), this->members_.m_start, start_n, new_start);
 this->members_.m_start = new_start;
-boost::move(start_n, pos, old_start);
+boost::container::move(start_n, pos, old_start);
-interf.copy_n_and_update(pos - n, n);
+proxy.copy_n_and_update(this->alloc(), pos - n, n);
 }
 else {
 const size_type mid_count = n - elemsbefore;
 const iterator mid_start = old_start - mid_count;
-interf.uninitialized_copy_n_and_update(mid_start, mid_count);
+proxy.uninitialized_copy_n_and_update(this->alloc(), mid_start, mid_count);
 this->members_.m_start = mid_start;
 ::boost::container::uninitialized_move_alloc
 (this->alloc(), old_start, pos, new_start);
 this->members_.m_start = new_start;
-interf.copy_n_and_update(old_start, elemsbefore);
+proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore);
 }
 }
 }
 else {
 const iterator new_finish = this->priv_reserve_elements_at_back(n);
 const iterator old_finish = this->members_.m_finish;
 const size_type elemsafter = length - elemsbefore;
 if(!elemsafter){
-interf.uninitialized_copy_n_and_update(old_finish, n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n);
 this->members_.m_finish = new_finish;
 }
 else{
 pos = old_finish - elemsafter;
 if (elemsafter >= n) {
 iterator finish_n = old_finish - difference_type(n);
 ::boost::container::uninitialized_move_alloc
 (this->alloc(), finish_n, old_finish, old_finish);
 this->members_.m_finish = new_finish;
-boost::move_backward(pos, finish_n, old_finish);
+boost::container::move_backward(pos, finish_n, old_finish);
-interf.copy_n_and_update(pos, n);
+proxy.copy_n_and_update(this->alloc(), pos, n);
 }
 else {
 const size_type raw_gap = n - elemsafter;
 ::boost::container::uninitialized_move_alloc
 (this->alloc(), pos, old_finish, old_finish + raw_gap);
 BOOST_TRY{
-interf.copy_n_and_update(pos, elemsafter);
+proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
-interf.uninitialized_copy_n_and_update(old_finish, raw_gap);
+proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
 }
 BOOST_CATCH(...){
 this->priv_destroy_range(old_finish, old_finish + elemsafter);
 BOOST_RETHROW
 }
 }
 return this->begin() + pos_n;
 }
 template <class InsertProxy>
-iterator priv_insert_back_aux_impl(size_type n, InsertProxy interf)
+iterator priv_insert_back_aux_impl(size_type n, InsertProxy proxy)
 {
 if(!this->members_.m_map){
 this->priv_initialize_map(0);
 }
 iterator new_finish = this->priv_reserve_elements_at_back(n);
 iterator old_finish = this->members_.m_finish;
-interf.uninitialized_copy_n_and_update(old_finish, n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n);
 this->members_.m_finish = new_finish;
 return iterator(this->members_.m_finish - n);
 }
 template <class InsertProxy>
-iterator priv_insert_front_aux_impl(size_type n, InsertProxy interf)
+iterator priv_insert_front_aux_impl(size_type n, InsertProxy proxy)
 {
 if(!this->members_.m_map){
 this->priv_initialize_map(0);
 }
 iterator new_start = this->priv_reserve_elements_at_front(n);
-interf.uninitialized_copy_n_and_update(new_start, n);
+proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
 this->members_.m_start = new_start;
 return new_start;
 }
 iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x)
 // Precondition: this->members_.m_start and this->members_.m_finish have already been initialized,
 // but none of the deque's elements have yet been constructed.
 void priv_fill_initialize(const value_type& value)
 {
-index_pointer cur;
+index_pointer cur = this->members_.m_start.m_node;
 BOOST_TRY {
-for (cur = this->members_.m_start.m_node; cur < this->members_.m_finish.m_node; ++cur){
+for ( ; cur < this->members_.m_finish.m_node; ++cur){
 boost::container::uninitialized_fill_alloc
 (this->alloc(), *cur, *cur + this->s_buffer_size(), value);
 }
 boost::container::uninitialized_fill_alloc
 (this->alloc(), this->members_.m_finish.m_first, this->members_.m_finish.m_cur, value);
 }
 BOOST_CATCH_END
 }
 template <class InIt>
-void priv_range_initialize(InIt first, InIt last, std::input_iterator_tag)
+typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type
+priv_range_initialize(InIt first, InIt last)
 {
 this->priv_initialize_map(0);
 BOOST_TRY {
 for ( ; first != last; ++first)
 this->emplace_back(*first);
 }
 BOOST_CATCH_END
 }
 template <class FwdIt>
-void priv_range_initialize(FwdIt first, FwdIt last, std::forward_iterator_tag)
+typename iterator_disable_if_tag<FwdIt, std::input_iterator_tag>::type
+priv_range_initialize(FwdIt first, FwdIt last)
 {
 size_type n = 0;
-n = std::distance(first, last);
+n = boost::container::iterator_distance(first, last);
 this->priv_initialize_map(n);
-index_pointer cur_node;
+index_pointer cur_node = this->members_.m_start.m_node;
 BOOST_TRY {
-for (cur_node = this->members_.m_start.m_node;
+for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
-cur_node < this->members_.m_finish.m_node;
-++cur_node) {
 FwdIt mid = first;
-std::advance(mid, this->s_buffer_size());
+boost::container::iterator_advance(mid, this->s_buffer_size());
 ::boost::container::uninitialized_copy_alloc(this->alloc(), first, mid, *cur_node);
 first = mid;
 }
 ::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.m_first);
 }
 }
 BOOST_CATCH_END
 }
 // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first.
-void priv_pop_back_aux() BOOST_CONTAINER_NOEXCEPT
+void priv_pop_back_aux() BOOST_NOEXCEPT_OR_NOTHROW
 {
 this->priv_deallocate_node(this->members_.m_finish.m_first);
 this->members_.m_finish.priv_set_node(this->members_.m_finish.m_node - 1);
 this->members_.m_finish.m_cur = this->members_.m_finish.m_last - 1;
 allocator_traits_type::destroy
 // Called only if this->members_.m_start.m_cur == this->members_.m_start.m_last - 1.  Note that
 // if the deque has at least one element (a precondition for this member
 // function), and if this->members_.m_start.m_cur == this->members_.m_start.m_last, then the deque
 // must have at least two nodes.
-void priv_pop_front_aux() BOOST_CONTAINER_NOEXCEPT
+void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW
 {
 allocator_traits_type::destroy
 ( this->alloc()
 , container_detail::to_raw_pointer(this->members_.m_start.m_cur)
 );
 this->priv_deallocate_node(this->members_.m_start.m_first);
 this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1);
 this->members_.m_start.m_cur = this->members_.m_start.m_first;
 }
 iterator priv_reserve_elements_at_front(size_type n)
 {
 size_type vacancies = this->members_.m_start.m_cur - this->members_.m_start.m_first;
 if (n > vacancies){
 for (; i <= new_nodes; ++i)
 *(this->members_.m_start.m_node - i) = this->priv_allocate_node();
 }
 BOOST_CATCH(...) {
 for (size_type j = 1; j < i; ++j)
 this->priv_deallocate_node(*(this->members_.m_start.m_node - j));
 BOOST_RETHROW
 }
 BOOST_CATCH_END
 }
 return this->members_.m_start - difference_type(n);
 size_type new_nodes = (new_elems + this->s_buffer_size() - 1)/s_buffer_size();
 size_type s = (size_type)(this->members_.m_map_size - (this->members_.m_finish.m_node - this->members_.m_map));
 if (new_nodes + 1 > s){
 this->priv_reallocate_map(new_nodes, false);
 }
-size_type i;
+size_type i = 1;
 BOOST_TRY {
-for (i = 1; i <= new_nodes; ++i)
+for (; i <= new_nodes; ++i)
 *(this->members_.m_finish.m_node + i) = this->priv_allocate_node();
 }
 BOOST_CATCH(...) {
 for (size_type j = 1; j < i; ++j)
 this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));
 BOOST_RETHROW
 }
 BOOST_CATCH_END
 }
 return this->members_.m_finish + difference_type(n);
 index_pointer new_nstart;
 if (this->members_.m_map_size > 2 * new_num_nodes) {
 new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2
 + (add_at_front ? nodes_to_add : 0);
 if (new_nstart < this->members_.m_start.m_node)
-boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
 else
-boost::move_backward
+boost::container::move_backward
 (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
 }
 else {
 size_type new_map_size =
 this->members_.m_map_size + container_detail::max_value(this->members_.m_map_size, nodes_to_add) + 2;
 index_pointer new_map = this->priv_allocate_map(new_map_size);
 new_nstart = new_map + (new_map_size - new_num_nodes) / 2
 + (add_at_front ? nodes_to_add : 0);
-boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
 this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
 this->members_.m_map = new_map;
 this->members_.m_map_size = new_map_size;
 }
 this->members_.m_start.priv_set_node(new_nstart);
 this->members_.m_finish.priv_set_node(new_nstart + old_num_nodes - 1);
 }
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
-// Nonmember functions.
-template <class T, class Allocator>
-inline bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{
-return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
-}
-template <class T, class Allocator>
-inline bool operator<(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{
-return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
-}
-template <class T, class Allocator>
-inline bool operator!=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{  return !(x == y);   }
-template <class T, class Allocator>
-inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{  return y < x; }
-template <class T, class Allocator>
-inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{  return !(x < y); }
-template <class T, class Allocator>
-inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
-{  return !(y < x); }
-template <class T, class Allocator>
-inline void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
-{  x.swap(y);  }
 }}
-/// @cond
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 namespace boost {
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
 template <class T, class Allocator>
 struct has_trivial_destructor_after_move<boost::container::deque<T, Allocator> >
-: public ::boost::has_trivial_destructor_after_move<Allocator>
+{
-{};
+typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+::boost::has_trivial_destructor_after_move<pointer>::value;
+};
 }
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 #include <boost/container/detail/config_end.hpp>
 #endif //   #ifndef  BOOST_CONTAINER_DEQUE_HPP

Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/container/deque.hpp @ 101:c530137014c0