passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/container/container_fwd.hpp

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2014. 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)
 //
@@ -11,34 +11,75 @@
 #ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
 #define BOOST_CONTAINER_CONTAINER_FWD_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
-#  pragma once
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
 #endif
 
-//////////////////////////////////////////////////////////////////////////////
-//                        Standard predeclarations
-//////////////////////////////////////////////////////////////////////////////
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
 
-/// @cond
+//! \file
+//! This header file forward declares the following containers:
+//!   - boost::container::vector
+//!   - boost::container::stable_vector
+//!   - boost::container::static_vector
+//!   - boost::container::small_vector
+//!   - boost::container::slist
+//!   - boost::container::list
+//!   - boost::container::set
+//!   - boost::container::multiset
+//!   - boost::container::map
+//!   - boost::container::multimap
+//!   - boost::container::flat_set
+//!   - boost::container::flat_multiset
+//!   - boost::container::flat_map
+//!   - boost::container::flat_multimap
+//!   - boost::container::basic_string
+//!   - boost::container::string
+//!   - boost::container::wstring
+//!
+//! Forward declares the following allocators:
+//!   - boost::container::allocator
+//!   - boost::container::node_allocator
+//!   - boost::container::adaptive_pool
+//!
+//! Forward declares the following polymorphic resource classes:
+//!   - boost::container::pmr::memory_resource
+//!   - boost::container::pmr::polymorphic_allocator
+//!   - boost::container::pmr::monotonic_buffer_resource
+//!   - boost::container::pmr::pool_options
+//!   - boost::container::pmr::unsynchronized_pool_resource
+//!   - boost::container::pmr::synchronized_pool_resource
+//!
+//! And finally it defines the following types
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//Std forward declarations
+#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
+   #include <boost/container/detail/std_fwd.hpp>
+#endif
 
 namespace boost{
 namespace intrusive{
+namespace detail{
    //Create namespace to avoid compilation errors
-}}
+}}}
 
 namespace boost{ namespace container{ namespace container_detail{
+   namespace bi = boost::intrusive;
+   namespace bid = boost::intrusive::detail;
+}}}
 
-namespace bi = boost::intrusive;
-
+namespace boost{ namespace container{ namespace pmr{
+   namespace bi = boost::intrusive;
+   namespace bid = boost::intrusive::detail;
 }}}
 
-#include <utility>
-#include <memory>
-#include <functional>
-#include <iosfwd>
-#include <string>
+#include <cstddef>
 
-/// @endcond
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //////////////////////////////////////////////////////////////////////////////
 //                             Containers
@@ -47,111 +88,212 @@ namespace bi = boost::intrusive;
 namespace boost {
 namespace container {
 
-//vector class
+//! Enumeration used to configure ordered associative containers
+//! with a concrete tree implementation.
+enum tree_type_enum
+{
+   red_black_tree,
+   avl_tree,
+   scapegoat_tree,
+   splay_tree
+};
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+template<class T>
+class new_allocator;
+
 template <class T
-         ,class Allocator = std::allocator<T> >
+         ,class Allocator = new_allocator<T> >
 class vector;
 
-//vector class
 template <class T
-         ,class Allocator = std::allocator<T> >
+         ,class Allocator = new_allocator<T> >
 class stable_vector;
 
-//vector class
+template <class T, std::size_t Capacity>
+class static_vector;
+
+template < class T, std::size_t N
+         , class Allocator= new_allocator<T> >
+class small_vector;
+
 template <class T
-         ,class Allocator = std::allocator<T> >
+         ,class Allocator = new_allocator<T> >
 class deque;
 
-//list class
 template <class T
-         ,class Allocator = std::allocator<T> >
+         ,class Allocator = new_allocator<T> >
 class list;
 
-//slist class
 template <class T
-         ,class Allocator = std::allocator<T> >
+         ,class Allocator = new_allocator<T> >
 class slist;
 
-//set class
+template<tree_type_enum TreeType, bool OptimizeSize>
+struct tree_opt;
+
+typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
+
 template <class Key
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<Key> >
+         ,class Allocator = new_allocator<Key>
+         ,class Options = tree_assoc_defaults >
 class set;
 
-//multiset class
 template <class Key
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<Key> >
+         ,class Allocator = new_allocator<Key>
+         ,class Options = tree_assoc_defaults >
 class multiset;
 
-//map class
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<std::pair<const Key, T> > >
+         ,class Allocator = new_allocator<std::pair<const Key, T> >
+         ,class Options = tree_assoc_defaults >
 class map;
 
-//multimap class
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<std::pair<const Key, T> > >
+         ,class Allocator = new_allocator<std::pair<const Key, T> >
+         ,class Options = tree_assoc_defaults >
 class multimap;
 
-//flat_set class
 template <class Key
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<Key> >
+         ,class Allocator = new_allocator<Key> >
 class flat_set;
 
-//flat_multiset class
 template <class Key
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<Key> >
+         ,class Allocator = new_allocator<Key> >
 class flat_multiset;
 
-//flat_map class
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<std::pair<Key, T> > >
+         ,class Allocator = new_allocator<std::pair<Key, T> > >
 class flat_map;
 
-//flat_multimap class
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Allocator = std::allocator<std::pair<Key, T> > >
+         ,class Allocator = new_allocator<std::pair<Key, T> > >
 class flat_multimap;
 
-//basic_string class
 template <class CharT
          ,class Traits = std::char_traits<CharT>
-         ,class Allocator  = std::allocator<CharT> >
+         ,class Allocator  = new_allocator<CharT> >
 class basic_string;
 
+typedef basic_string
+   <char
+   ,std::char_traits<char>
+   ,new_allocator<char> >
+string;
+
+typedef basic_string
+   <wchar_t
+   ,std::char_traits<wchar_t>
+   ,new_allocator<wchar_t> >
+wstring;
+
+static const std::size_t ADP_nodes_per_block    = 256u;
+static const std::size_t ADP_max_free_blocks    = 2u;
+static const std::size_t ADP_overhead_percent   = 1u;
+static const std::size_t ADP_only_alignment     = 0u;
+
+template < class T
+         , std::size_t NodesPerBlock   = ADP_nodes_per_block
+         , std::size_t MaxFreeBlocks   = ADP_max_free_blocks
+         , std::size_t OverheadPercent = ADP_overhead_percent
+         , unsigned Version = 2
+         >
+class adaptive_pool;
+
+template < class T
+         , unsigned Version = 2
+         , unsigned int AllocationDisableMask = 0>
+class allocator;
+
+static const std::size_t NodeAlloc_nodes_per_block = 256u;
+
+template
+   < class T
+   , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
+   , std::size_t Version = 2>
+class node_allocator;
+
+namespace pmr {
+
+class memory_resource;
+
+template<class T>
+class polymorphic_allocator;
+
+class monotonic_buffer_resource;
+
+struct pool_options;
+
+template <class Allocator>
+class resource_adaptor_imp;
+
+class unsynchronized_pool_resource;
+
+class synchronized_pool_resource;
+
+}  //namespace pmr {
+
+#else
+
+//! Default options for tree-based associative containers
+//!   - tree_type<red_black_tree>
+//!   - optimize_size<true>
+typedef implementation_defined tree_assoc_defaults;
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
 //! Type used to tag that the input range is
 //! guaranteed to be ordered
 struct ordered_range_t
 {};
 
+//! Value used to tag that the input range is
+//! guaranteed to be ordered
+static const ordered_range_t ordered_range = ordered_range_t();
+
 //! Type used to tag that the input range is
 //! guaranteed to be ordered and unique
 struct ordered_unique_range_t
    : public ordered_range_t
 {};
 
-//! Value used to tag that the input range is
-//! guaranteed to be ordered
-static const ordered_range_t ordered_range = ordered_range_t();
-
 //! Value used to tag that the input range is
 //! guaranteed to be ordered and unique
 static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
 
-/// @cond
+//! Type used to tag that the inserted values
+//! should be default initialized
+struct default_init_t
+{};
+
+//! Value used to tag that the inserted values
+//! should be default initialized
+static const default_init_t default_init = default_init_t();
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! Type used to tag that the inserted values
+//! should be value initialized
+struct value_init_t
+{};
+
+//! Value used to tag that the inserted values
+//! should be value initialized
+static const value_init_t value_init = value_init_t();
 
-namespace detail_really_deep_namespace {
+namespace container_detail_really_deep_namespace {
 
 //Otherwise, gcc issues a warning of previously defined
 //anonymous_instance and unique_instance
@@ -161,12 +303,14 @@ struct dummy
    {
       (void)ordered_range;
       (void)ordered_unique_range;
+      (void)default_init;
    }
 };
 
 }  //detail_really_deep_namespace {
 
-/// @endcond
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 }}  //namespace boost { namespace container {
 

data/src/cxx_supportlib/vendor-modified/boost/container/deque.hpp

@@ -1,380 +1,330 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2015. 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.
 //
 //////////////////////////////////////////////////////////////////////////////
-// Copyright (c) 1996,1997
-// Silicon Graphics Computer Systems, Inc.
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  Silicon Graphics makes no
-// representations about the suitability of this software for any
-// purpose.  It is provided "as is" without express or implied warranty.
-//
-//
-// Copyright (c) 1994
-// Hewlett-Packard Company
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  Hewlett-Packard Company makes no
-// representations about the suitability of this software for any
-// purpose.  It is provided "as is" without express or implied warranty.
-
 #ifndef BOOST_CONTAINER_DEQUE_HPP
 #define BOOST_CONTAINER_DEQUE_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#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>
-
-#include <boost/container/detail/utilities.hpp>
-#include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/algorithms.hpp>
-#include <boost/container/detail/mpl.hpp>
+// container
 #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>
-#include <cstddef>
-#include <iterator>
-#include <boost/assert.hpp>
-#include <memory>
-#include <algorithm>
-#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>
+// 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>
-#include <boost/container/detail/advanced_insert_int.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+// other
+#include <boost/assert.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+// std
+#include <cstddef>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>
+#endif
 
 namespace boost {
 namespace container {
 
-/// @cond
-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Allocator = std::allocator<T> >
-#else
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class Allocator>
-#endif
 class deque;
 
-template <class T, class Allocator>
+template <class T>
 struct deque_value_traits
 {
    typedef T value_type;
-   typedef Allocator allocator_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.
-inline std::size_t deque_buf_size(std::size_t size)
-   {  return size < 512 ? std::size_t(512 / size) : std::size_t(1);  }
+template<class T>
+struct deque_buf_size
+{
+   static const std::size_t min_size = 512u;
+   static const std::size_t sizeof_t = sizeof(T);
+   static const std::size_t value    = sizeof_t < min_size ? (min_size/sizeof_t) : std::size_t(1);
+};
 
-// Deque base class.  It has two purposes.  First, its constructor
-//  and destructor allocate (but don't initialize) storage.  This makes
-//  exception safety easier.
-template <class T, class Allocator>
-class deque_base
+namespace container_detail {
+
+// Class invariants:
+//  For any nonsingular iterator i:
+//    i.node is the address of an element in the map array.  The
+//      contents of i.node is a pointer to the beginning of a node.
+//    i.first == //(i.node)
+//    i.last  == i.first + node_size
+//    i.cur is a pointer in the range [i.first, i.last).  NOTE:
+//      the implication of this is that i.cur is always a dereferenceable
+//      pointer, even if i is a past-the-end iterator.
+//  Start and Finish are always nonsingular iterators.  NOTE: this means
+//    that an empty deque must have one node, and that a deque
+//    with N elements, where N is the buffer size, must have two nodes.
+//  For every node other than start.node and finish.node, every element
+//    in the node is an initialized object.  If start.node == finish.node,
+//    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).
+//  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
 {
-   BOOST_COPYABLE_AND_MOVABLE(deque_base)
    public:
-   typedef allocator_traits<Allocator>                            val_alloc_traits_type;
-   typedef typename val_alloc_traits_type::value_type             val_alloc_val;
-   typedef typename val_alloc_traits_type::pointer                val_alloc_ptr;
-   typedef typename val_alloc_traits_type::const_pointer          val_alloc_cptr;
-   typedef typename val_alloc_traits_type::reference              val_alloc_ref;
-   typedef typename val_alloc_traits_type::const_reference        val_alloc_cref;
-   typedef typename val_alloc_traits_type::difference_type        val_alloc_diff;
-   typedef typename val_alloc_traits_type::size_type              val_alloc_size;
-   typedef typename val_alloc_traits_type::template
-      portable_rebind_alloc<val_alloc_ptr>::type                  ptr_alloc_t;
-   typedef allocator_traits<ptr_alloc_t>                          ptr_alloc_traits_type;
-   typedef typename ptr_alloc_traits_type::value_type             ptr_alloc_val;
-   typedef typename ptr_alloc_traits_type::pointer                ptr_alloc_ptr;
-   typedef typename ptr_alloc_traits_type::const_pointer          ptr_alloc_cptr;
-   typedef typename ptr_alloc_traits_type::reference              ptr_alloc_ref;
-   typedef typename ptr_alloc_traits_type::const_reference        ptr_alloc_cref;
-   typedef Allocator                                                      allocator_type;
-   typedef allocator_type                                         stored_allocator_type;
-   typedef val_alloc_size                                         size_type;
+   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
+                                 rebind_pointer<const value_type>::type
+      , Pointer
+      >::type                                                                       pointer;
+   typedef typename if_c
+      < IsConst
+      , const value_type&
+      , value_type&
+      >::type                                                                       reference;
+
+   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;
 
-   protected:
+   public:
 
-   typedef deque_value_traits<T, Allocator>             traits_t;
-   typedef ptr_alloc_t                          map_allocator_type;
+   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;  }
 
-   static size_type s_buffer_size() { return deque_buf_size(sizeof(T)); }
+   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)
+   {}
 
-   val_alloc_ptr priv_allocate_node()
-      {  return this->alloc().allocate(s_buffer_size());  }
+   deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
+      : m_cur(), m_first(), m_last(), m_node()  //Value initialization to achieve "null iterators" (N3644)
+   {}
 
-   void priv_deallocate_node(val_alloc_ptr p)
-      {  this->alloc().deallocate(p, s_buffer_size());  }
+   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())
+   {}
 
-   ptr_alloc_ptr priv_allocate_map(size_type n)
-      { return this->ptr_alloc().allocate(n); }
+   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)
+   {}
 
-   void priv_deallocate_map(ptr_alloc_ptr p, size_type n)
-      { this->ptr_alloc().deallocate(p, n); }
+   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());
+   }
 
- public:
-   // Class invariants:
-   //  For any nonsingular iterator i:
-   //    i.node is the address of an element in the map array.  The
-   //      contents of i.node is a pointer to the beginning of a node.
-   //    i.first == //(i.node)
-   //    i.last  == i.first + node_size
-   //    i.cur is a pointer in the range [i.first, i.last).  NOTE:
-   //      the implication of this is that i.cur is always a dereferenceable
-   //      pointer, even if i is a past-the-end iterator.
-   //  Start and Finish are always nonsingular iterators.  NOTE: this means
-   //    that an empty deque must have one node, and that a deque
-   //    with N elements, where N is the buffer size, must have two nodes.
-   //  For every node other than start.node and finish.node, every element
-   //    in the node is an initialized object.  If start.node == finish.node,
-   //    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
-   //    if and only if the pointer is in the range [start.node, finish.node].
-   class const_iterator
-      : public std::iterator<std::random_access_iterator_tag,
-                              val_alloc_val,  val_alloc_diff,
-                              val_alloc_cptr, val_alloc_cref>
-   {
-      public:
-      static size_type s_buffer_size() { return deque_base<T, Allocator>::s_buffer_size(); }
-
-      typedef std::random_access_iterator_tag   iterator_category;
-      typedef val_alloc_val                     value_type;
-      typedef val_alloc_cptr                    pointer;
-      typedef val_alloc_cref                    reference;
-      typedef val_alloc_diff                    difference_type;
-
-      typedef ptr_alloc_ptr                     index_pointer;
-      typedef const_iterator                    self_t;
-
-      friend class deque<T, Allocator>;
-      friend class deque_base<T, Allocator>;
-
-      protected:
-      val_alloc_ptr  m_cur;
-      val_alloc_ptr  m_first;
-      val_alloc_ptr  m_last;
-      index_pointer  m_node;
-
-      public:
-      const_iterator(val_alloc_ptr x, index_pointer y)
-         : m_cur(x), m_first(*y),
-           m_last(*y + s_buffer_size()), m_node(y) {}
-
-      const_iterator() : m_cur(0), m_first(0), m_last(0), m_node(0) {}
-
-      const_iterator(const const_iterator& x)
-         : m_cur(x.m_cur),   m_first(x.m_first),
-           m_last(x.m_last), m_node(x.m_node) {}
-
-      reference operator*() const
-         { return *this->m_cur; }
-
-      pointer operator->() const
-         { return this->m_cur; }
-
-      difference_type operator-(const self_t& x) const
-      {
-         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);
-      }
+   reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return *this->m_cur; }
 
-      self_t& operator++()
-      {
-         ++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;
-      }
+   pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return this->m_cur; }
 
-      self_t operator++(int) 
-      {
-         self_t tmp = *this;
-         ++*this;
-         return tmp;
+   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);
+   }
 
-      self_t& operator--()
-      {
-         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++() 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;
+   }
 
-      self_t operator--(int)
-      {
-         self_t tmp = *this;
-         --*this;
-         return tmp;
-      }
+   deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      deque_iterator tmp(*this);
+      ++*this;
+      return tmp;
+   }
 
-      self_t& operator+=(difference_type n)
-      {
-         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 {
-            difference_type node_offset =
-            offset > 0 ? offset / difference_type(this->s_buffer_size())
-                        : -difference_type((-offset - 1) / this->s_buffer_size()) - 1;
-            this->priv_set_node(this->m_node + node_offset);
-            this->m_cur = this->m_first +
-            (offset - node_offset * difference_type(this->s_buffer_size()));
-         }
-         return *this;
+   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;
+   }
 
-      self_t operator+(difference_type n) const
-         {  self_t tmp = *this; return tmp += n;  }
-
-      self_t& operator-=(difference_type n)
-         { return *this += -n; }
-      
-      self_t operator-(difference_type n) const
-         {  self_t tmp = *this; return tmp -= n;  }
-
-      reference operator[](difference_type n) const
-         { return *(*this + n); }
+   deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      deque_iterator tmp(*this);
+      --*this;
+      return tmp;
+   }
 
-      bool operator==(const self_t& x) const
-         { return this->m_cur == x.m_cur; }
+   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 {
+         difference_type node_offset =
+         offset > 0 ? offset / difference_type(this->s_buffer_size())
+                     : -difference_type((-offset - 1) / this->s_buffer_size()) - 1;
+         this->priv_set_node(this->m_node + node_offset);
+         this->m_cur = this->m_first +
+         (offset - node_offset * difference_type(this->s_buffer_size()));
+      }
+      return *this;
+   }
 
-      bool operator!=(const self_t& x) const
-         { return !(*this == x); }
+   deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+      {  deque_iterator tmp(*this); return tmp += n;  }
 
-      bool operator<(const self_t& x) const
-      {
-         return (this->m_node == x.m_node) ?
-            (this->m_cur < x.m_cur) : (this->m_node < x.m_node);
-      }
+   deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
+      { return *this += -n; }
 
-      bool operator>(const self_t& x) const 
-         { return x < *this; }
+   deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+      {  deque_iterator tmp(*this); return tmp -= n;  }
 
-      bool operator<=(const self_t& x) const
-         { return !(x < *this); }
+   reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+      { return *(*this + n); }
 
-      bool operator>=(const self_t& x) const
-         { return !(*this < x); }
+   friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+      { return l.m_cur == r.m_cur; }
 
-      void priv_set_node(index_pointer new_node)
-      {
-         this->m_node = new_node;
-         this->m_first = *new_node;
-         this->m_last = this->m_first + this->s_buffer_size();
-      }
+   friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+      { return l.m_cur != r.m_cur; }
 
-      friend const_iterator operator+(difference_type n, const const_iterator& x)
-         {  return x + n;  }
-   };
+   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);  }
 
-   //Deque iterator
-   class iterator : public const_iterator
-   {
-      public:
-      typedef std::random_access_iterator_tag   iterator_category;
-      typedef val_alloc_val                     value_type;
-      typedef val_alloc_ptr                     pointer;
-      typedef val_alloc_ref                     reference;
-      typedef val_alloc_diff                    difference_type;
-      typedef ptr_alloc_ptr                     index_pointer;
-      typedef const_iterator                    self_t;
+   friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+      { return r < l; }
 
-      friend class deque<T, Allocator>;
-      friend class deque_base<T, Allocator>;
+   friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+      { return !(r < l); }
 
-      private:
-      explicit iterator(const const_iterator& x) : const_iterator(x){}
+   friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+      { return !(l < r); }
 
-      public:
-      //Constructors
-      iterator(val_alloc_ptr x, index_pointer y) : const_iterator(x, y){}
-      iterator() : const_iterator(){}
-      //iterator(const const_iterator &cit) : const_iterator(cit){}
-      iterator(const iterator& x) : const_iterator(x){}
+   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();
+   }
 
-      //Pointer like operators
-      reference operator*() const { return *this->m_cur; }
-      pointer operator->() const { return this->m_cur; }
+   friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
+      {  return x += n;  }
+};
 
-      reference operator[](difference_type n) const { return *(*this + n); }
+}  //namespace container_detail {
 
-      //Increment / Decrement
-      iterator& operator++() 
-         { this->const_iterator::operator++(); return *this;  }
+// Deque base class.  It has two purposes.  First, its constructor
+//  and destructor allocate (but don't initialize) storage.  This makes
+//  exception safety easier.
+template <class Allocator>
+class deque_base
+{
+   BOOST_COPYABLE_AND_MOVABLE(deque_base)
+   public:
+   typedef allocator_traits<Allocator>                            val_alloc_traits_type;
+   typedef typename val_alloc_traits_type::value_type             val_alloc_val;
+   typedef typename val_alloc_traits_type::pointer                val_alloc_ptr;
+   typedef typename val_alloc_traits_type::const_pointer          val_alloc_cptr;
+   typedef typename val_alloc_traits_type::reference              val_alloc_ref;
+   typedef typename val_alloc_traits_type::const_reference        val_alloc_cref;
+   typedef typename val_alloc_traits_type::difference_type        val_alloc_diff;
+   typedef typename val_alloc_traits_type::size_type              val_alloc_size;
+   typedef typename val_alloc_traits_type::template
+      portable_rebind_alloc<val_alloc_ptr>::type                  ptr_alloc_t;
+   typedef allocator_traits<ptr_alloc_t>                          ptr_alloc_traits_type;
+   typedef typename ptr_alloc_traits_type::value_type             ptr_alloc_val;
+   typedef typename ptr_alloc_traits_type::pointer                ptr_alloc_ptr;
+   typedef typename ptr_alloc_traits_type::const_pointer          ptr_alloc_cptr;
+   typedef typename ptr_alloc_traits_type::reference              ptr_alloc_ref;
+   typedef typename ptr_alloc_traits_type::const_reference        ptr_alloc_cref;
+   typedef Allocator                                                      allocator_type;
+   typedef allocator_type                                         stored_allocator_type;
+   typedef val_alloc_size                                         size_type;
 
-      iterator operator++(int)
-         { iterator tmp = *this; ++*this; return tmp; }
-     
-      iterator& operator--()
-         {  this->const_iterator::operator--(); return *this;  }
+   protected:
 
-      iterator operator--(int)
-         {  iterator tmp = *this; --*this; return tmp; }
+   typedef deque_value_traits<val_alloc_val>             traits_t;
+   typedef ptr_alloc_t                                   map_allocator_type;
 
-      // Arithmetic
-      iterator& operator+=(difference_type off)
-         {  this->const_iterator::operator+=(off); return *this;  }
+   static size_type s_buffer_size() BOOST_NOEXCEPT_OR_NOTHROW
+      { return deque_buf_size<val_alloc_val>::value; }
 
-      iterator operator+(difference_type off) const
-         {  return iterator(this->const_iterator::operator+(off));  }
+   val_alloc_ptr priv_allocate_node()
+      {  return this->alloc().allocate(s_buffer_size());  }
 
-      friend iterator operator+(difference_type off, const iterator& right)
-         {  return iterator(off+static_cast<const const_iterator &>(right)); }
+   void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
+      {  this->alloc().deallocate(p, s_buffer_size());  }
 
-      iterator& operator-=(difference_type off)
-         {  this->const_iterator::operator-=(off); return *this;   }
+   ptr_alloc_ptr priv_allocate_map(size_type n)
+      { return this->ptr_alloc().allocate(n); }
 
-      iterator operator-(difference_type off) const
-         {  return iterator(this->const_iterator::operator-(off));  }
+   void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+      { this->ptr_alloc().deallocate(p, n); }
 
-      difference_type operator-(const const_iterator& right) const
-         {  return static_cast<const const_iterator&>(*this) - right;   }
-   };
+   typedef container_detail::deque_iterator<val_alloc_ptr, false> iterator;
+   typedef container_detail::deque_iterator<val_alloc_ptr, true > const_iterator;
 
    deque_base(size_type num_elements, const allocator_type& a)
       :  members_(a)
@@ -403,15 +353,15 @@ class deque_base
 
    private:
    deque_base(const deque_base&);
- 
+
    protected:
 
-   void swap_members(deque_base &x)
+   void swap_members(deque_base &x) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      std::swap(this->members_.m_start, x.members_.m_start);
-      std::swap(this->members_.m_finish, x.members_.m_finish);
-      std::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_start, x.members_.m_start);
+      ::boost::adl_move_swap(this->members_.m_finish, x.members_.m_finish);
+      ::boost::adl_move_swap(this->members_.m_map, x.members_.m_map);
+      ::boost::adl_move_swap(this->members_.m_map_size, x.members_.m_map_size);
    }
 
    void priv_initialize_map(size_type num_elements)
@@ -424,7 +374,7 @@ class deque_base
 
          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);
          }
@@ -446,9 +396,9 @@ class deque_base
 
    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(...){
@@ -458,13 +408,13 @@ class deque_base
       BOOST_CATCH_END
    }
 
-   void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
+   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()
+   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);
@@ -509,33 +459,36 @@ class deque_base
       iterator        m_finish;
    } members_;
 
-   ptr_alloc_t &ptr_alloc()
+   ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
-  
-   const ptr_alloc_t &ptr_alloc() const
+
+   const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 
-   allocator_type &alloc()
+   allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
-  
-   const allocator_type &alloc() const
+
+   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
-template <class T, class Allocator = std::allocator<T> >
+//! 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.
+//!
+//! \tparam T The type of object that is stored in the deque
+//! \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<T, Allocator>
+class deque : protected deque_base<Allocator>
 {
-   /// @cond
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
-   typedef deque_base<T, Allocator> Base;
-   /// @endcond
+   typedef deque_base<Allocator> Base;
+   #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
 
@@ -556,10 +509,10 @@ class deque : protected deque_base<T, Allocator>
    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(std::reverse_iterator<const_iterator>)               const_reverse_iterator;
+   typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<iterator>)        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)
@@ -568,7 +521,7 @@ class deque : protected deque_base<T, Allocator>
       { return Base::s_buffer_size(); }
    typedef allocator_traits<Allocator>                  allocator_traits_type;
 
-   /// @endcond
+   #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
    //////////////////////////////////////////////
@@ -591,30 +544,79 @@ class deque : protected deque_base<T, Allocator>
    //! <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
-   //!   and inserts n default contructed values.
+   //! <b>Effects</b>: Constructs a deque
+   //!   and inserts n value initialized values.
    //!
-   //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
-   //!   throws or T's default or copy constructor throws.
+   //! <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)
       : Base(n, allocator_type())
    {
-      container_detail::insert_default_constructed_n_proxy<Allocator, iterator> proxy(this->alloc());
-      proxy.uninitialized_copy_n_and_update(this->begin(), n);
+      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
+   //!   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)
+      : Base(n, allocator_type())
+   {
+      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 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
-   //!   throws or T's default or copy constructor throws.
+   //! <b>Throws</b>: If allocator_type's default constructor
+   //!   throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
    deque(size_type n, const value_type& value,
@@ -625,8 +627,8 @@ class deque : protected deque_base<T, Allocator>
    //! <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
-   //!   throws or T's constructor taking an dereferenced InIt throws.
+   //! <b>Throws</b>: If allocator_type's default constructor
+   //!   throws or T's constructor taking a dereferenced InIt throws.
    //!
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InIt>
@@ -639,9 +641,23 @@ class deque : protected deque_base<T, Allocator>
       )
       : Base(a)
    {
-      typedef typename std::iterator_traits<InIt>::iterator_category ItCat;
-      this->priv_range_initialize(first, last, ItCat());
+      this->priv_range_initialize(first, last);
+   }
+
+#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.
    //!
@@ -658,13 +674,13 @@ class deque : protected deque_base<T, Allocator>
       }
    }
 
-   //! <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.
@@ -686,23 +702,24 @@ class deque : protected deque_base<T, Allocator>
    }
 
    //! <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.
-   deque(BOOST_RV_REF(deque) mx, const allocator_type &a)
+   //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
+   deque(BOOST_RV_REF(deque) x, const allocator_type &a)
       :  Base(a)
    {
-      if(mx.alloc() == a){
-         this->swap_members(mx);
+      if(x.alloc() == a){
+         this->swap_members(x);
       }
       else{
-         if(mx.size()){
-            this->priv_initialize_map(mx.size());
+         if(x.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);
          }
       }
    }
@@ -713,7 +730,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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);
    }
@@ -744,40 +761,60 @@ class deque : protected deque_base<T, Allocator>
       return *this;
    }
 
-   //! <b>Effects</b>: Move assignment. All mx's values are transferred to *this.
-   //!
-   //! <b>Postcondition</b>: x.empty(). *this contains a the elements x had
-   //!   before the function.
+   //! <b>Effects</b>: Move assignment. All x's values are transferred to *this.
    //!
-   //! <b>Throws</b>: If allocator_type's copy constructor throws.
+   //! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment
+   //!   is false and (allocation throws or value_type's move constructor throws)
    //!
-   //! <b>Complexity</b>: Linear.
+   //! <b>Complexity</b>: Constant if allocator_traits_type::
+   //!   propagate_on_container_move_assignment is true or
+   //!   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
+                                  || allocator_traits_type::is_always_equal::value)
    {
-      if (&x != this){
-         allocator_type &this_alloc = this->alloc();
-         allocator_type &x_alloc    = x.alloc();
-         //If allocators are equal we can just swap pointers
-         if(this_alloc == x_alloc){
-            //Destroy objects but retain memory in case x reuses it in the future
-            this->clear();
-            this->swap_members(x);
-            //Move allocator if needed
-            container_detail::bool_<allocator_traits_type::
-               propagate_on_container_move_assignment::value> flag;
-            container_detail::move_alloc(this_alloc, x_alloc, flag);
-            container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
-         }
-         //If unequal allocators, then do a one by one move
-         else{
-            typedef typename std::iterator_traits<iterator>::iterator_category ItCat;
-            this->assign( boost::make_move_iterator(x.begin())
-                        , boost::make_move_iterator(x.end()));
-         }
+      BOOST_ASSERT(this != &x);
+      allocator_type &this_alloc = this->alloc();
+      allocator_type &x_alloc    = x.alloc();
+      const bool propagate_alloc = allocator_traits_type::
+            propagate_on_container_move_assignment::value;
+      container_detail::bool_<propagate_alloc> flag;
+      const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
+      //Resources can be transferred if both allocators are
+      //going to be equal after this function (either propagated or already equal)
+      if(propagate_alloc || allocators_equal){
+         //Destroy objects but retain memory in case x reuses it in the future
+         this->clear();
+         //Move allocator if needed
+         container_detail::move_alloc(this_alloc, x_alloc, flag);
+         container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+         //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.
@@ -798,9 +835,10 @@ class deque : protected deque_base<T, Allocator>
    template <class InIt>
    void assign(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<InIt, size_type>::value
-            && container_detail::is_input_iterator<InIt>::value
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_convertible<InIt, size_type>
+         , container_detail::is_not_input_iterator<InIt>
          >::type * = 0
       #endif
       )
@@ -820,16 +858,17 @@ class deque : protected deque_base<T, Allocator>
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    void assign(FwdIt first, FwdIt last
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<FwdIt, size_type>::value
-            && !container_detail::is_input_iterator<FwdIt>::value
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_convertible<FwdIt, size_type>
+         , container_detail::is_input_iterator<FwdIt>
          >::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);
       }
@@ -839,12 +878,23 @@ class deque : protected deque_base<T, Allocator>
    }
    #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.
@@ -854,7 +904,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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(); }
 
    //////////////////////////////////////////////
@@ -870,7 +920,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -878,7 +928,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -886,7 +936,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -894,7 +944,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -902,7 +952,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -911,7 +961,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -920,7 +970,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -929,7 +979,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -938,7 +988,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -946,7 +996,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -954,7 +1004,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -963,7 +1013,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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
@@ -972,7 +1022,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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); }
 
    //////////////////////////////////////////////
@@ -986,7 +1036,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -994,7 +1044,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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.
@@ -1002,13 +1052,13 @@ class deque : protected deque_base<T, Allocator>
    //! <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 default constructed.
+   //!   the size becomes n. New elements are value initialized.
    //!
-   //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
+   //! <b>Throws</b>: If memory allocation throws, or T's constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    void resize(size_type new_size)
@@ -1018,7 +1068,27 @@ class deque : protected deque_base<T, Allocator>
          this->priv_erase_last_n(len - new_size);
       else{
          const size_type n = new_size - this->size();
-         container_detail::insert_default_constructed_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
+   //!   the size becomes n. New elements are default initialized.
+   //!
+   //! <b>Throws</b>: If memory allocation throws, or T's constructor throws.
+   //!
+   //! <b>Complexity</b>: Linear to the difference between size() and new_size.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   void resize(size_type new_size, default_init_t)
+   {
+      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;
          priv_insert_back_aux_impl(n, proxy);
       }
    }
@@ -1069,8 +1139,11 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reference front() BOOST_CONTAINER_NOEXCEPT
-      { return *this->members_.m_start; }
+   reference front() BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(!this->empty());
+      return *this->members_.m_start;
+   }
 
    //! <b>Requires</b>: !empty()
    //!
@@ -1080,8 +1153,11 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reference front() const BOOST_CONTAINER_NOEXCEPT
-      { return *this->members_.m_start; }
+   const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(!this->empty());
+      return *this->members_.m_start;
+   }
 
    //! <b>Requires</b>: !empty()
    //!
@@ -1091,8 +1167,11 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reference back() BOOST_CONTAINER_NOEXCEPT
-      {  return *(end()-1); }
+   reference back() BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(!this->empty());
+      return *(end()-1);
+   }
 
    //! <b>Requires</b>: !empty()
    //!
@@ -1102,8 +1181,11 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reference back() const BOOST_CONTAINER_NOEXCEPT
-      {  return *(cend()-1);  }
+   const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(!this->empty());
+      return *(cend()-1);
+   }
 
    //! <b>Requires</b>: size() > n.
    //!
@@ -1113,8 +1195,11 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reference operator[](size_type n) BOOST_CONTAINER_NOEXCEPT
-      { return this->members_.m_start[difference_type(n)]; }
+   reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(this->size() > n);
+      return this->members_.m_start[difference_type(n)];
+   }
 
    //! <b>Requires</b>: size() > n.
    //!
@@ -1124,8 +1209,78 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reference operator[](size_type n) const BOOST_CONTAINER_NOEXCEPT
-      { return this->members_.m_start[difference_type(n)]; }
+   const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(this->size() > n);
+      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
+   {
+      //Range checked priv_index_of
+      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
+   {
+      //Range checked priv_index_of
+      return this->priv_index_of(p);
+   }
 
    //! <b>Requires</b>: size() > n.
    //!
@@ -1136,7 +1291,10 @@ class deque : protected deque_base<T, Allocator>
    //!
    //! <b>Complexity</b>: Constant.
    reference at(size_type n)
-      { this->priv_range_check(n); return (*this)[n]; }
+   {
+      this->priv_throw_if_out_of_range(n);
+      return (*this)[n];
+   }
 
    //! <b>Requires</b>: size() > n.
    //!
@@ -1147,7 +1305,10 @@ class deque : protected deque_base<T, Allocator>
    //!
    //! <b>Complexity</b>: Constant.
    const_reference at(size_type n) const
-      { this->priv_range_check(n); return (*this)[n]; }
+   {
+      this->priv_throw_if_out_of_range(n);
+      return (*this)[n];
+   }
 
    //////////////////////////////////////////////
    //
@@ -1155,7 +1316,7 @@ class deque : protected deque_base<T, Allocator>
    //
    //////////////////////////////////////////////
 
-   #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.
@@ -1164,7 +1325,7 @@ class deque : protected deque_base<T, Allocator>
    //!
    //! <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
@@ -1174,8 +1335,8 @@ class deque : protected deque_base<T, Allocator>
          this->priv_push_front_simple_commit();
       }
       else{
-         typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type;
-         this->priv_insert_front_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...));
+         typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
+         this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...));
       }
    }
 
@@ -1186,7 +1347,7 @@ class deque : protected deque_base<T, Allocator>
    //!
    //! <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
@@ -1196,23 +1357,24 @@ class deque : protected deque_base<T, Allocator>
          this->priv_push_back_simple_commit();
       }
       else{
-         typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type;
-         this->priv_insert_back_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...));
+         typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
+         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)
    {
+      BOOST_ASSERT(this->priv_in_range_or_end(p));
       if(p == this->cbegin()){
          this->emplace_front(boost::forward<Args>(args)...);
          return this->begin();
@@ -1223,74 +1385,66 @@ class deque : protected deque_base<T, Allocator>
       }
       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)...));
-      }
-   }
-
-   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
-   //advanced_insert_int.hpp includes all necessary preprocessor machinery...
-   #define BOOST_PP_LOCAL_MACRO(n)                                                           \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >  )  \
-   void emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                    \
-   {                                                                                         \
-      if(priv_push_front_simple_available()){                                                \
-         allocator_traits_type::construct                                                    \
-            ( this->alloc()                                                                  \
-            , this->priv_push_front_simple_pos()                                             \
-              BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));               \
-         priv_push_front_simple_commit();                                                    \
-      }                                                                                      \
-      else{                                                                                  \
-         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_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)    \
-   void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                     \
-   {                                                                                         \
-      if(priv_push_back_simple_available()){                                                 \
-         allocator_traits_type::construct                                                    \
-            ( this->alloc()                                                                  \
-            , this->priv_push_back_simple_pos()                                              \
-              BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));               \
-         priv_push_back_simple_commit();                                                     \
-      }                                                                                      \
-      else{                                                                                  \
-         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_back_aux_impl(1, proxy);                                                \
-      }                                                                                      \
-   }                                                                                         \
-                                                                                             \
-   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)    \
-   iterator emplace(const_iterator p                                                         \
-                    BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))             \
-   {                                                                                         \
-      if(p == this->cbegin()){                                                               \
-         this->emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));         \
-         return this->begin();                                                               \
-      }                                                                                      \
-      else if(p == cend()){                                                                  \
-         this->emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));          \
-         return (this->end()-1);                                                             \
-      }                                                                                      \
-      else{                                                                                  \
-         container_detail::BOOST_PP_CAT(insert_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, _));  \
-         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
+         return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
+      }
+   }
+
+   #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   #define BOOST_CONTAINER_DEQUE_EMPLACE_CODE(N) \
+   BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
+   void emplace_front(BOOST_MOVE_UREF##N)\
+   {\
+      if(priv_push_front_simple_available()){\
+         allocator_traits_type::construct\
+            ( this->alloc(), this->priv_push_front_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         priv_push_front_simple_commit();\
+      }\
+      else{\
+         typedef container_detail::insert_nonmovable_emplace_proxy##N\
+               <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+         priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\
+      }\
+   }\
+   \
+   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()){\
+         allocator_traits_type::construct\
+            ( this->alloc(), this->priv_push_back_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         priv_push_back_simple_commit();\
+      }\
+      else{\
+         typedef container_detail::insert_nonmovable_emplace_proxy##N\
+               <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+         priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\
+      }\
+   }\
+   \
+   BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
+   iterator emplace(const_iterator p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {\
+      BOOST_ASSERT(this->priv_in_range_or_end(p));\
+      if(p == this->cbegin()){\
+         this->emplace_front(BOOST_MOVE_FWD##N);\
+         return this->begin();\
+      }\
+      else if(p == cend()){\
+         this->emplace_back(BOOST_MOVE_FWD##N);\
+         return (--this->end());\
+      }\
+      else{\
+         typedef container_detail::insert_emplace_proxy_arg##N\
+               <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+         return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
+      }\
+   }
+   //
+   BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEQUE_EMPLACE_CODE)
+   #undef BOOST_CONTAINER_DEQUE_EMPLACE_CODE
+
+   #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    //! <b>Effects</b>: Inserts a copy of x at the front of the deque.
@@ -1302,7 +1456,7 @@ class deque : protected deque_base<T, Allocator>
    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.
    //!
@@ -1322,7 +1476,7 @@ class deque : protected deque_base<T, Allocator>
    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.
    //!
@@ -1334,31 +1488,31 @@ class deque : protected deque_base<T, Allocator>
 
    #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)
+   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.
@@ -1372,6 +1526,7 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Complexity</b>: Linear to n.
    iterator insert(const_iterator pos, size_type n, const value_type& x)
    {
+      //Range check of p is done by insert()
       typedef constant_iterator<value_type, difference_type> c_it;
       return this->insert(pos, c_it(x, n), c_it());
    }
@@ -1385,19 +1540,21 @@ class deque : protected deque_base<T, Allocator>
    //! <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
-            && container_detail::is_input_iterator<InIt>::value
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_convertible<InIt, size_type>
+         , container_detail::is_not_input_iterator<InIt>
          >::type * = 0
       #endif
       )
    {
+      BOOST_ASSERT(this->priv_in_range_or_end(pos));
       size_type n = 0;
-      iterator it(pos);
+      iterator it(pos.unconst());
       for(;first != last; ++first, ++n){
          it = this->emplace(it, *first);
          ++it;
@@ -1406,19 +1563,39 @@ class deque : protected deque_base<T, Allocator>
       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)
+   {
+      //Range check os pos is done in insert()
+      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)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<FwdIt, size_type>::value
-            && !container_detail::is_input_iterator<FwdIt>::value
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_convertible<FwdIt, size_type>
+         , container_detail::is_input_iterator<FwdIt>
          >::type * = 0
       #endif
       )
    {
-      container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(this->alloc(), first);
-      return priv_insert_aux_impl(p, (size_type)std::distance(first, last), proxy);
+      BOOST_ASSERT(this->priv_in_range_or_end(p));
+      container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(first);
+      return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy);
    }
    #endif
 
@@ -1427,8 +1604,9 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant time.
-   void pop_front() BOOST_CONTAINER_NOEXCEPT
+   void pop_front() BOOST_NOEXCEPT_OR_NOTHROW
    {
+      BOOST_ASSERT(!this->empty());
       if (this->members_.m_start.m_cur != this->members_.m_start.m_last - 1) {
          allocator_traits_type::destroy
             ( this->alloc()
@@ -1445,8 +1623,9 @@ class deque : protected deque_base<T, Allocator>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant time.
-   void pop_back() BOOST_CONTAINER_NOEXCEPT
+   void pop_back() BOOST_NOEXCEPT_OR_NOTHROW
    {
+      BOOST_ASSERT(!this->empty());
       if (this->members_.m_finish.m_cur != this->members_.m_finish.m_first) {
          --this->members_.m_finish.m_cur;
          allocator_traits_type::destroy
@@ -1458,7 +1637,7 @@ class deque : protected deque_base<T, Allocator>
          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.
    //!
@@ -1466,17 +1645,18 @@ class deque : protected deque_base<T, Allocator>
    //!   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
    {
-      const_iterator next = pos;
+      BOOST_ASSERT(this->priv_in_range(pos));
+      iterator next = pos.unconst();
       ++next;
       size_type index = pos - this->members_.m_start;
       if (index < (this->size()/2)) {
-         boost::move_backward(begin(), iterator(pos), iterator(next));
+         boost::container::move_backward(this->begin(), pos.unconst(), next);
          pop_front();
       }
       else {
-         boost::move(iterator(next), end(), iterator(pos));
+         boost::container::move(next, this->end(), pos.unconst());
          pop_back();
       }
       return this->members_.m_start + index;
@@ -1490,8 +1670,10 @@ class deque : protected deque_base<T, Allocator>
    //!   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
    {
+      BOOST_ASSERT(first == last ||
+         (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last)));
       if (first == this->members_.m_start && last == this->members_.m_finish) {
          this->clear();
          return this->members_.m_finish;
@@ -1500,7 +1682,7 @@ class deque : protected deque_base<T, Allocator>
          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(), iterator(first), iterator(last));
+            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);
@@ -1508,7 +1690,7 @@ class deque : protected deque_base<T, Allocator>
             this->members_.m_start = new_start;
          }
          else {
-            boost::move(iterator(last), end(), iterator(first));
+            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);
@@ -1525,6 +1707,8 @@ class deque : protected deque_base<T, Allocator>
    //!
    //! <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;
@@ -1537,7 +1721,7 @@ class deque : protected deque_base<T, Allocator>
    //! <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;
@@ -1557,9 +1741,58 @@ class deque : protected deque_base<T, Allocator>
       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()) {
@@ -1574,23 +1807,38 @@ class deque : protected deque_base<T, Allocator>
       }
    }
 
-   void priv_range_check(size_type n) const
-      {  if (n >= this->size())  throw_out_of_range("deque::at out of range");   }
+   void priv_throw_if_out_of_range(size_type n) const
+   {
+      if (n >= this->size())
+         throw_out_of_range("deque::at out of range");
+   }
+
+   bool priv_in_range(const_iterator pos) const
+   {
+      return (this->begin() <= pos) && (pos < this->end());
+   }
+
+   bool priv_in_range_or_end(const_iterator pos) const
+   {
+      return (this->begin() <= pos) && (pos <= this->end());
+   }
 
    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()){
+      BOOST_ASSERT(this->priv_in_range_or_end(p));
+      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)));
       }
    }
 
@@ -1604,7 +1852,8 @@ class deque : protected deque_base<T, Allocator>
       }
       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)));
       }
    }
 
@@ -1618,8 +1867,8 @@ class deque : protected deque_base<T, Allocator>
       }
       else{
          priv_insert_aux_impl
-            (this->cend(), (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x)));
-         container_detail::insert_copy_proxy<Allocator, iterator> proxy(this->alloc(), x);
+            ( this->cend(), (size_type)1
+            , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
       }
    }
 
@@ -1653,28 +1902,26 @@ class deque : protected deque_base<T, Allocator>
 
    void priv_destroy_range(iterator p, iterator p2)
    {
-      for(;p != p2; ++p){
-         allocator_traits_type::destroy
-            ( this->alloc()
-            , container_detail::to_raw_pointer(&*p)
-            );
+      if(!Base::traits_t::trivial_dctr){
+         for(;p != p2; ++p){
+            allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p));
+         }
       }
    }
 
    void priv_destroy_range(pointer p, pointer p2)
    {
-      for(;p != p2; ++p){
-         allocator_traits_type::destroy
-            ( this->alloc()
-            , container_detail::to_raw_pointer(&*p)
-            );
+      if(!Base::traits_t::trivial_dctr){
+         for(;p != p2; ++p){
+            allocator_traits_type::destroy(this->alloc(), container_detail::iterator_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);
+      iterator pos(p.unconst());
       const size_type pos_n = p - this->cbegin();
       if(!this->members_.m_map){
          this->priv_initialize_map(0);
@@ -1687,7 +1934,7 @@ class deque : protected deque_base<T, Allocator>
          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{
@@ -1697,18 +1944,18 @@ class deque : protected deque_base<T, Allocator>
                ::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);
-               interf.copy_n_and_update(pos - n, n);
+               boost::container::move(start_n, pos, old_start);
+               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);
             }
          }
       }
@@ -1717,7 +1964,7 @@ class deque : protected deque_base<T, Allocator>
          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{
@@ -1727,16 +1974,16 @@ class deque : protected deque_base<T, Allocator>
                ::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);
-               interf.copy_n_and_update(pos, n);
+               boost::container::move_backward(pos, finish_n, old_finish);
+               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);
-                  interf.uninitialized_copy_n_and_update(old_finish, raw_gap);
+                  proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
+                  proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
                }
                BOOST_CATCH(...){
                   this->priv_destroy_range(old_finish, old_finish + elemsafter);
@@ -1751,7 +1998,7 @@ class deque : protected deque_base<T, Allocator>
    }
 
    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);
@@ -1759,20 +2006,20 @@ class deque : protected deque_base<T, Allocator>
 
       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;
    }
@@ -1787,9 +2034,9 @@ class deque : protected deque_base<T, Allocator>
    // 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);
          }
@@ -1804,7 +2051,7 @@ class deque : protected deque_base<T, Allocator>
    }
 
    template <class InIt>
-   void priv_range_initialize(InIt first, InIt last, std::input_iterator_tag)
+   void priv_range_initialize(InIt first, InIt last, typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type* =0)
    {
       this->priv_initialize_map(0);
       BOOST_TRY {
@@ -1819,19 +2066,17 @@ class deque : protected deque_base<T, Allocator>
    }
 
    template <class FwdIt>
-   void priv_range_initialize(FwdIt first, FwdIt last, std::forward_iterator_tag)
+   void priv_range_initialize(FwdIt first, FwdIt last, typename iterator_disable_if_tag<FwdIt, std::input_iterator_tag>::type* =0)
    {
       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;
-               cur_node < this->members_.m_finish.m_node;
-               ++cur_node) {
+         for (; 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;
          }
@@ -1845,7 +2090,7 @@ class deque : protected deque_base<T, Allocator>
    }
 
    // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first.
-   void priv_pop_back_aux()
+   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);
@@ -1860,7 +2105,7 @@ class deque : protected deque_base<T, Allocator>
    // 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()
+   void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW
    {
       allocator_traits_type::destroy
          ( this->alloc()
@@ -1869,7 +2114,7 @@ class deque : protected deque_base<T, Allocator>
       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)
    {
@@ -1889,7 +2134,7 @@ class deque : protected deque_base<T, Allocator>
          }
          BOOST_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));     
+               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -1907,14 +2152,14 @@ class deque : protected deque_base<T, Allocator>
          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));     
+               this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -1932,9 +2177,9 @@ class deque : protected deque_base<T, Allocator>
          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 {
@@ -1944,7 +2189,7 @@ class deque : protected deque_base<T, Allocator>
          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;
@@ -1954,45 +2199,12 @@ class deque : protected deque_base<T, Allocator>
       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)
-{
-   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)
-{
-   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)
-   {  return !(x == y);   }
-
-template <class T, class Allocator>
-inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
-   {  return y < x; }
-
-template <class T, class Allocator>
-inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
-   {  return !(x < y); }
-
-template <class T, class Allocator>
-inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
-   {  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 {
 
@@ -2000,12 +2212,15 @@ namespace boost {
 //!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>