Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r85443 - in branches/release: boost/container boost/container/detail libs/container libs/container/doc libs/container/test
From: igaztanaga_at_[hidden]
Date: 2013-08-24 06:41:09


Author: igaztanaga
Date: 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013)
New Revision: 85443
URL: http://svn.boost.org/trac/boost/changeset/85443

Log:
Merged revision(s) 84341-85442 from trunk/boost/container. Merged revision(s) 84342-85442 from trunk/libs/container. First Container merge for 1.55

Properties modified:
   branches/release/boost/container/ (props changed)
   branches/release/libs/container/ (props changed)
Text files modified:
   branches/release/boost/container/deque.hpp | 502 ++++++++++++++++++---------------------
   branches/release/boost/container/detail/flat_tree.hpp | 19 +
   branches/release/boost/container/detail/iterators.hpp | 97 +++++++
   branches/release/boost/container/detail/node_alloc_holder.hpp | 21
   branches/release/boost/container/detail/tree.hpp | 145 ++---------
   branches/release/boost/container/detail/utilities.hpp | 4
   branches/release/boost/container/detail/workaround.hpp | 6
   branches/release/boost/container/flat_map.hpp | 33 ++
   branches/release/boost/container/flat_set.hpp | 38 ++
   branches/release/boost/container/list.hpp | 115 --------
   branches/release/boost/container/map.hpp | 24 +
   branches/release/boost/container/set.hpp | 14 +
   branches/release/boost/container/slist.hpp | 101 -------
   branches/release/boost/container/stable_vector.hpp | 174 +++++++------
   branches/release/boost/container/static_vector.hpp | 7
   branches/release/boost/container/vector.hpp | 163 ++++--------
   branches/release/libs/container/doc/container.qbk | 76 ++++-
   branches/release/libs/container/test/check_equal_containers.hpp | 2
   branches/release/libs/container/test/flat_tree_test.cpp | 7
   branches/release/libs/container/test/list_test.cpp | 8
   branches/release/libs/container/test/slist_test.cpp | 9
   branches/release/libs/container/test/stable_vector_test.cpp | 6
   branches/release/libs/container/test/tree_test.cpp | 8
   branches/release/libs/container/test/vector_test.cpp | 4
   24 files changed, 741 insertions(+), 842 deletions(-)

Modified: branches/release/boost/container/deque.hpp
==============================================================================
--- branches/release/boost/container/deque.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/deque.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -75,11 +75,10 @@
 #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_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value;
    static const bool trivial_copy = has_trivial_copy<value_type>::value;
@@ -91,290 +90,257 @@
 
 // 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).
+// 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].
+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_CONTAINER_NOEXCEPT
+ : 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_CONTAINER_NOEXCEPT
+ : m_cur(), m_first(), m_last(), m_node()
+ {}
 
- void priv_deallocate_node(val_alloc_ptr p)
- { this->alloc().deallocate(p, s_buffer_size()); }
+ deque_iterator(deque_iterator<Pointer, false> const& x) BOOST_CONTAINER_NOEXCEPT
+ : 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_CONTAINER_NOEXCEPT
+ : 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_CONTAINER_NOEXCEPT
+ {
+ 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_CONTAINER_NOEXCEPT
+ { 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_CONTAINER_NOEXCEPT
+ { return this->m_cur; }
 
- self_t operator++(int)
- {
- self_t tmp = *this;
- ++*this;
- return tmp;
+ difference_type operator-(const deque_iterator& x) const BOOST_CONTAINER_NOEXCEPT
+ {
+ 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_CONTAINER_NOEXCEPT
+ {
+ ++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;
- }
-
- 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++(int) BOOST_CONTAINER_NOEXCEPT
+ {
+ deque_iterator tmp(*this);
+ ++*this;
+ return tmp;
+ }
+
+ deque_iterator& operator--() BOOST_CONTAINER_NOEXCEPT
+ {
+ 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; }
+ deque_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
+ {
+ deque_iterator tmp(*this);
+ --*this;
+ return tmp;
+ }
 
- self_t& operator-=(difference_type n)
- { return *this += -n; }
-
- self_t operator-(difference_type n) const
- { self_t tmp = *this; return tmp -= n; }
+ deque_iterator& operator+=(difference_type n) BOOST_CONTAINER_NOEXCEPT
+ {
+ 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;
+ }
 
- reference operator[](difference_type n) const
- { return *(*this + n); }
+ deque_iterator operator+(difference_type n) const BOOST_CONTAINER_NOEXCEPT
+ { deque_iterator tmp(*this); return tmp += n; }
 
- bool operator==(const self_t& x) const
- { return this->m_cur == x.m_cur; }
+ deque_iterator& operator-=(difference_type n) BOOST_CONTAINER_NOEXCEPT
+ { return *this += -n; }
+
+ deque_iterator operator-(difference_type n) const BOOST_CONTAINER_NOEXCEPT
+ { deque_iterator tmp(*this); return tmp -= n; }
 
- bool operator!=(const self_t& x) const
- { return !(*this == x); }
+ reference operator[](difference_type n) const BOOST_CONTAINER_NOEXCEPT
+ { return *(*this + 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);
- }
+ friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_cur == r.m_cur; }
 
- bool operator>(const self_t& x) const
- { return x < *this; }
+ friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_cur != r.m_cur; }
 
- bool operator<=(const self_t& x) const
- { return !(x < *this); }
+ friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node); }
 
- bool operator>=(const self_t& x) const
- { return !(*this < x); }
+ friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return r < l; }
 
- 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_CONTAINER_NOEXCEPT
+ { return !(r < l); }
 
- 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_CONTAINER_NOEXCEPT
+ { return !(l < r); }
 
- //Deque iterator
- class iterator : public const_iterator
+ void priv_set_node(index_pointer new_node) BOOST_CONTAINER_NOEXCEPT
    {
- 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 class deque<T, Allocator>;
- friend class deque_base<T, Allocator>;
-
- private:
- explicit iterator(const const_iterator& x) : const_iterator(x){}
-
- 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){}
+ 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_CONTAINER_NOEXCEPT
+ { 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_CONTAINER_NOEXCEPT
+ { 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_CONTAINER_NOEXCEPT
+ { 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_CONTAINER_NOEXCEPT
+ { 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)
@@ -406,7 +372,7 @@
  
    protected:
 
- void swap_members(deque_base &x)
+ void swap_members(deque_base &x) BOOST_CONTAINER_NOEXCEPT
    {
       std::swap(this->members_.m_start, x.members_.m_start);
       std::swap(this->members_.m_finish, x.members_.m_finish);
@@ -458,13 +424,13 @@
       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_CONTAINER_NOEXCEPT
    {
       for (ptr_alloc_ptr n = nstart; n < nfinish; ++n)
          this->priv_deallocate_node(*n);
    }
 
- void priv_clear_map()
+ void priv_clear_map() BOOST_CONTAINER_NOEXCEPT
    {
       if (this->members_.m_map) {
          this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1);
@@ -509,16 +475,16 @@
       iterator m_finish;
    } members_;
 
- ptr_alloc_t &ptr_alloc()
+ ptr_alloc_t &ptr_alloc() BOOST_CONTAINER_NOEXCEPT
    { return members_; }
   
- const ptr_alloc_t &ptr_alloc() const
+ const ptr_alloc_t &ptr_alloc() const BOOST_CONTAINER_NOEXCEPT
    { return members_; }
 
- allocator_type &alloc()
+ allocator_type &alloc() BOOST_CONTAINER_NOEXCEPT
    { return members_; }
   
- const allocator_type &alloc() const
+ const allocator_type &alloc() const BOOST_CONTAINER_NOEXCEPT
    { return members_; }
 };
 /// @endcond
@@ -530,11 +496,11 @@
 #else
 template <class T, class Allocator>
 #endif
-class deque : protected deque_base<T, Allocator>
+class deque : protected deque_base<Allocator>
 {
    /// @cond
    private:
- typedef deque_base<T, Allocator> Base;
+ typedef deque_base<Allocator> Base;
    /// @endcond
 
    public:
@@ -1397,7 +1363,7 @@
       )
    {
       size_type n = 0;
- iterator it(pos);
+ iterator it(pos.unconst());
       for(;first != last; ++first, ++n){
          it = this->emplace(it, *first);
          ++it;
@@ -1468,15 +1434,15 @@
    //! Constant if pos is the first or the last element.
    iterator erase(const_iterator pos) BOOST_CONTAINER_NOEXCEPT
    {
- const_iterator next = 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::move_backward(this->begin(), pos.unconst(), next);
          pop_front();
       }
       else {
- boost::move(iterator(next), end(), iterator(pos));
+ boost::move(next, this->end(), pos.unconst());
          pop_back();
       }
       return this->members_.m_start + index;
@@ -1500,7 +1466,7 @@
          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::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 +1474,7 @@
             this->members_.m_start = new_start;
          }
          else {
- boost::move(iterator(last), end(), iterator(first));
+ boost::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);
@@ -1674,7 +1640,7 @@
    template<class InsertProxy>
    iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy interf)
    {
- 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);
@@ -1845,7 +1811,7 @@
    }
 
    // 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_CONTAINER_NOEXCEPT
    {
       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 +1826,7 @@
    // 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_CONTAINER_NOEXCEPT
    {
       allocator_traits_type::destroy
          ( this->alloc()
@@ -1959,31 +1925,31 @@
 
 // Nonmember functions.
 template <class T, class Allocator>
-inline bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
 {
    return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
 }
 
 template <class T, class Allocator>
-inline bool operator<(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator<(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
 {
    return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
 }
 
 template <class T, class Allocator>
-inline bool operator!=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator!=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
    { return !(x == y); }
 
 template <class T, class Allocator>
-inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
    { return y < x; }
 
 template <class T, class Allocator>
-inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
    { return !(x < y); }
 
 template <class T, class Allocator>
-inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
+inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT
    { return !(y < x); }
 
 template <class T, class Allocator>

Modified: branches/release/boost/container/detail/flat_tree.hpp
==============================================================================
--- branches/release/boost/container/detail/flat_tree.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/flat_tree.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -85,9 +85,9 @@
          rebind_pointer<const iterator_element_type>::type const_iterator;
    #else //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
    typedef typename container_detail::
- vector_iterator<Pointer> iterator;
+ vec_iterator<Pointer, false> iterator;
    typedef typename container_detail::
- vector_const_iterator<Pointer> const_iterator;
+ vec_iterator<Pointer, true > const_iterator;
    #endif //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -115,7 +115,7 @@
          : value_compare(), m_vect()
       {}
 
- Data(const Data &d)
+ explicit Data(const Data &d)
          : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect)
       {}
 
@@ -131,15 +131,18 @@
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect), a)
       {}
 
- Data(const Compare &comp)
+ explicit Data(const Compare &comp)
          : value_compare(comp), m_vect()
       {}
 
- Data(const Compare &comp,
- const allocator_t &alloc)
+ Data(const Compare &comp, const allocator_t &alloc)
          : value_compare(comp), m_vect(alloc)
       {}
 
+ explicit Data(const allocator_t &alloc)
+ : value_compare(), m_vect(alloc)
+ {}
+
       Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
       {
          this->value_compare::operator=(d);
@@ -203,6 +206,10 @@
       : m_data(comp, a)
    { }
 
+ explicit flat_tree(const allocator_type& a)
+ : m_data(a)
+ { }
+
    flat_tree(const flat_tree& x)
       : m_data(x.m_data)
    { }

Modified: branches/release/boost/container/detail/iterators.hpp
==============================================================================
--- branches/release/boost/container/detail/iterators.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/iterators.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -23,6 +23,7 @@
 #include <boost/move/utility.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/type_traits.hpp>
+#include <boost/static_assert.hpp>
 
 #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 #include <boost/container/detail/variadic_templates_tools.hpp>
@@ -585,24 +586,112 @@
    static const bool value = false;
 };
 
-template<class T, class IIterator>
+template<class IIterator>
 struct iiterator_types
 {
+ typedef typename IIterator::value_type it_value_type;
+ typedef typename it_value_type::value_type value_type;
    typedef typename std::iterator_traits<IIterator>::pointer it_pointer;
    typedef typename std::iterator_traits<IIterator>::difference_type difference_type;
    typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
- template rebind_pointer<T>::type pointer;
+ template rebind_pointer<value_type>::type pointer;
    typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
- template rebind_pointer<const T>::type const_pointer;
+ template rebind_pointer<const value_type>::type const_pointer;
    typedef typename ::boost::intrusive::
       pointer_traits<pointer>::reference reference;
    typedef typename ::boost::intrusive::
       pointer_traits<const_pointer>::reference const_reference;
+ typedef typename IIterator::iterator_category iterator_category;
 };
 
+template<class IIterator, bool IsConst>
+struct std_iterator
+{
+ typedef typename std::iterator
+ < typename iiterator_types<IIterator>::iterator_category
+ , typename iiterator_types<IIterator>::value_type
+ , typename iiterator_types<IIterator>::difference_type
+ , typename iiterator_types<IIterator>::const_pointer
+ , typename iiterator_types<IIterator>::const_reference> type;
+};
 
-} //namespace container_detail {
+template<class IIterator>
+struct std_iterator<IIterator, false>
+{
+ typedef typename std::iterator
+ < typename iiterator_types<IIterator>::iterator_category
+ , typename iiterator_types<IIterator>::value_type
+ , typename iiterator_types<IIterator>::difference_type
+ , typename iiterator_types<IIterator>::pointer
+ , typename iiterator_types<IIterator>::reference> type;
+};
+
+template<class IIterator, bool IsConst>
+class iterator
+ : public std_iterator<IIterator, IsConst>::type
+{
+ typedef typename std_iterator<IIterator, IsConst>::type types_t;
+
+ public:
+ typedef typename types_t::value_type value_type;
+ typedef typename types_t::pointer pointer;
+ typedef typename types_t::reference reference;
+
+ iterator()
+ {}
+
+ explicit iterator(IIterator iit) BOOST_CONTAINER_NOEXCEPT
+ : m_iit(iit)
+ {}
+
+ iterator(iterator<IIterator, false> const& other) BOOST_CONTAINER_NOEXCEPT
+ : m_iit(other.get())
+ {}
+
+ iterator& operator++() BOOST_CONTAINER_NOEXCEPT
+ { ++this->m_iit; return *this; }
+
+ iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
+ {
+ iterator result (*this);
+ ++this->m_iit;
+ return result;
+ }
+
+ iterator& operator--() BOOST_CONTAINER_NOEXCEPT
+ {
+ //If the iterator is not a bidirectional iterator, operator-- should not exist
+ BOOST_STATIC_ASSERT((is_bidirectional_iterator<iterator>::value));
+ --this->m_iit; return *this;
+ }
+
+ iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
+ {
+ iterator result (*this);
+ --this->m_iit;
+ return result;
+ }
 
+ friend bool operator== (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_iit == r.m_iit; }
+
+ friend bool operator!= (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return !(l == r); }
+
+ reference operator*() const BOOST_CONTAINER_NOEXCEPT
+ { return (*this->m_iit).get_data(); }
+
+ pointer operator->() const BOOST_CONTAINER_NOEXCEPT
+ { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*()); }
+
+ const IIterator &get() const BOOST_CONTAINER_NOEXCEPT
+ { return this->m_iit; }
+
+ private:
+ IIterator m_iit;
+};
+
+} //namespace container_detail {
 } //namespace container {
 } //namespace boost {
 

Modified: branches/release/boost/container/detail/node_alloc_holder.hpp
==============================================================================
--- branches/release/boost/container/detail/node_alloc_holder.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/node_alloc_holder.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -53,10 +53,14 @@
    typedef typename ValueCompare::value_type value_type;
    typedef typename ValueCompare::key_of_value key_of_value;
 
- node_compare(const ValueCompare &pred)
+ explicit node_compare(const ValueCompare &pred)
       : ValueCompare(pred)
    {}
 
+ node_compare()
+ : ValueCompare()
+ {}
+
    ValueCompare &value_comp()
    { return static_cast<ValueCompare &>(*this); }
 
@@ -67,11 +71,10 @@
    { return ValueCompare::operator()(a.get_data(), b.get_data()); }
 };
 
-template<class A, class ICont, class Pred = container_detail::nat>
+template<class A, class ICont, class ValPred = container_detail::nat>
 struct node_alloc_holder
 {
    typedef allocator_traits<A> allocator_traits_type;
- typedef node_alloc_holder<A, ICont> self_t;
    typedef typename allocator_traits_type::value_type value_type;
    typedef typename ICont::value_type Node;
    typedef typename allocator_traits_type::template
@@ -116,20 +119,20 @@
    { this->icont().swap(x.icont()); }
 
    //Constructors for associative containers
- explicit node_alloc_holder(const ValAlloc &a, const Pred &c)
+ explicit node_alloc_holder(const ValAlloc &a, const ValPred &c)
       : members_(a, c)
    {}
 
- explicit node_alloc_holder(const node_alloc_holder &x, const Pred &c)
+ explicit node_alloc_holder(const node_alloc_holder &x, const ValPred &c)
       : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
    {}
 
- explicit node_alloc_holder(const Pred &c)
+ explicit node_alloc_holder(const ValPred &c)
       : members_(c)
    {}
 
    //helpers for move assignments
- explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const Pred &c)
+ explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const ValPred &c)
       : members_(boost::move(x.node_alloc()), c)
    { this->icont().swap(x.icont()); }
 
@@ -345,12 +348,12 @@
       {}
 
       template<class ConvertibleToAlloc>
- members_holder(BOOST_FWD_REF(ConvertibleToAlloc) c2alloc, const Pred &c)
+ members_holder(BOOST_FWD_REF(ConvertibleToAlloc) c2alloc, const ValPred &c)
          : NodeAlloc(boost::forward<ConvertibleToAlloc>(c2alloc))
          , m_icont(typename ICont::value_compare(c))
       {}
 
- explicit members_holder(const Pred &c)
+ explicit members_holder(const ValPred &c)
          : NodeAlloc()
          , m_icont(typename ICont::value_compare(c))
       {}

Modified: branches/release/boost/container/detail/tree.hpp
==============================================================================
--- branches/release/boost/container/detail/tree.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/tree.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -20,8 +20,8 @@
 #include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/detail/no_exceptions_support.hpp>
 #include <boost/intrusive/rbtree.hpp>
-
 #include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/algorithms.hpp>
 #include <boost/container/detail/node_alloc_holder.hpp>
 #include <boost/container/detail/destroyers.hpp>
@@ -50,8 +50,12 @@
    typedef KeyOfValue key_of_value;
    typedef Key key_type;
 
- tree_value_compare(const key_compare &kcomp)
- : key_compare(kcomp)
+ explicit tree_value_compare(const key_compare &kcomp)
+ : KeyCompare(kcomp)
+ {}
+
+ tree_value_compare()
+ : KeyCompare()
    {}
 
    const key_compare &key_comp() const
@@ -212,15 +216,15 @@
       , typename container_detail::intrusive_rbtree_type
          <A, tree_value_compare<Key, Value, KeyCompare, KeyOfValue>
>::type
- , KeyCompare
+ , tree_value_compare<Key, Value, KeyCompare, KeyOfValue>
>
 {
+ typedef tree_value_compare
+ <Key, Value, KeyCompare, KeyOfValue> ValComp;
    typedef typename container_detail::intrusive_rbtree_type
- < A, tree_value_compare
- <Key, Value, KeyCompare, KeyOfValue>
- >::type Icont;
+ < A, ValComp>::type Icont;
    typedef container_detail::node_alloc_holder
- <A, Icont, KeyCompare> AllocHolder;
+ <A, Icont, ValComp> AllocHolder;
    typedef typename AllocHolder::NodePtr NodePtr;
    typedef rbtree < Key, Value, KeyOfValue
                   , KeyCompare, A> ThisType;
@@ -318,8 +322,7 @@
    typedef Value value_type;
    typedef A allocator_type;
    typedef KeyCompare key_compare;
- typedef tree_value_compare< Key, Value
- , KeyCompare, KeyOfValue> value_compare;
+ typedef ValComp value_compare;
    typedef typename boost::container::
       allocator_traits<A>::pointer pointer;
    typedef typename boost::container::
@@ -373,109 +376,21 @@
    typedef key_node_compare<value_compare> KeyNodeCompare;
 
    public:
- //rbtree const_iterator
- class const_iterator
- : public std::iterator
- < std::bidirectional_iterator_tag
- , value_type , rbtree_difference_type
- , rbtree_const_pointer , rbtree_const_reference>
- {
- protected:
- typedef typename Icont::iterator iiterator;
- iiterator m_it;
- explicit const_iterator(iiterator it) : m_it(it){}
- void prot_incr() { ++m_it; }
- void prot_decr() { --m_it; }
-
- private:
- iiterator get()
- { return this->m_it; }
-
- public:
- friend class rbtree <Key, Value, KeyOfValue, KeyCompare, A>;
- typedef rbtree_difference_type difference_type;
-
- //Constructors
- const_iterator()
- : m_it()
- {}
-
- //Pointer like operators
- const_reference operator*() const
- { return m_it->get_data(); }
-
- const_pointer operator->() const
- { return const_pointer(&m_it->get_data()); }
-
- //Increment / Decrement
- const_iterator& operator++()
- { prot_incr(); return *this; }
-
- const_iterator operator++(int)
- { iiterator tmp = m_it; ++*this; return const_iterator(tmp); }
-
- const_iterator& operator--()
- { prot_decr(); return *this; }
-
- const_iterator operator--(int)
- { iiterator tmp = m_it; --*this; return const_iterator(tmp); }
-
- //Comparison operators
- bool operator== (const const_iterator& r) const
- { return m_it == r.m_it; }
-
- bool operator!= (const const_iterator& r) const
- { return m_it != r.m_it; }
- };
-
- //rbtree iterator
- class iterator : public const_iterator
- {
- private:
- explicit iterator(iiterator it)
- : const_iterator(it)
- {}
-
- iiterator get()
- { return this->m_it; }
-
- public:
- friend class rbtree <Key, Value, KeyOfValue, KeyCompare, A>;
- typedef rbtree_pointer pointer;
- typedef rbtree_reference reference;
-
- //Constructors
- iterator(){}
-
- //Pointer like operators
- reference operator*() const
- { return this->m_it->get_data(); }
- pointer operator->() const
- { return boost::intrusive::pointer_traits<pointer>::pointer_to(this->m_it->get_data()); }
-
- //Increment / Decrement
- iterator& operator++()
- { this->prot_incr(); return *this; }
-
- iterator operator++(int)
- { iiterator tmp = this->m_it; ++*this; return iterator(tmp); }
-
- iterator& operator--()
- { this->prot_decr(); return *this; }
-
- iterator operator--(int)
- { iterator tmp = *this; --*this; return tmp; }
- };
-
+ typedef container_detail::iterator<iiterator, false> iterator;
+ typedef container_detail::iterator<iiterator, true > const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
    rbtree()
- : AllocHolder(key_compare())
+ : AllocHolder(ValComp(key_compare()))
+ {}
+
+ explicit rbtree(const key_compare& comp, const allocator_type& a = allocator_type())
+ : AllocHolder(a, ValComp(comp))
    {}
 
- rbtree(const key_compare& comp, const allocator_type& a = allocator_type())
- : AllocHolder(a, comp)
+ explicit rbtree(const allocator_type& a)
+ : AllocHolder(a)
    {}
 
    template <class InputIterator>
@@ -488,7 +403,7 @@
>::type * = 0
       #endif
          )
- : AllocHolder(a, comp)
+ : AllocHolder(a, value_compare(comp))
    {
       if(unique_insertion){
          this->insert_unique(first, last);
@@ -508,7 +423,7 @@
>::type * = 0
       #endif
          )
- : AllocHolder(a, comp)
+ : AllocHolder(a, value_compare(comp))
    {
       if(unique_insertion){
          this->insert_unique(first, last);
@@ -530,7 +445,7 @@
>::type * = 0
          #endif
          )
- : AllocHolder(a, comp)
+ : AllocHolder(a, value_compare(comp))
    {
       this->insert_equal(first, last);
    }
@@ -545,7 +460,7 @@
>::type * = 0
          #endif
          )
- : AllocHolder(a, comp)
+ : AllocHolder(a, value_compare(comp))
    {
       //Optimized allocation and construction
       this->allocate_many_and_construct
@@ -553,25 +468,25 @@
    }
 
    rbtree(const rbtree& x)
- : AllocHolder(x, x.key_comp())
+ : AllocHolder(x, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
    }
 
    rbtree(BOOST_RV_REF(rbtree) x)
- : AllocHolder(::boost::move(static_cast<AllocHolder&>(x)), x.key_comp())
+ : AllocHolder(::boost::move(static_cast<AllocHolder&>(x)), x.value_comp())
    {}
 
    rbtree(const rbtree& x, const allocator_type &a)
- : AllocHolder(a, x.key_comp())
+ : AllocHolder(a, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
    }
 
    rbtree(BOOST_RV_REF(rbtree) x, const allocator_type &a)
- : AllocHolder(a, x.key_comp())
+ : AllocHolder(a, x.value_comp())
    {
       if(this->node_alloc() == x.node_alloc()){
          this->icont().swap(x.icont());

Modified: branches/release/boost/container/detail/utilities.hpp
==============================================================================
--- branches/release/boost/container/detail/utilities.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/utilities.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -12,6 +12,7 @@
 #define BOOST_CONTAINER_DETAIL_UTILITIES_HPP
 
 #include "config_begin.hpp"
+#include "workaround.hpp"
 #include <cstdio>
 #include <cstring> //for ::memcpy
 #include <boost/type_traits/is_fundamental.hpp>
@@ -1055,18 +1056,21 @@
          ::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
+ BOOST_CONTAINER_FALLTHOUGH
       case 3:
          ::memcpy(stora_ptr, large_ptr, sizeof_storage);
          ::memcpy(large_ptr, short_ptr, sizeof_storage);
          ::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
+ BOOST_CONTAINER_FALLTHOUGH
       case 2:
          ::memcpy(stora_ptr, large_ptr, sizeof_storage);
          ::memcpy(large_ptr, short_ptr, sizeof_storage);
          ::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
+ BOOST_CONTAINER_FALLTHOUGH
       case 1:
          ::memcpy(stora_ptr, large_ptr, sizeof_storage);
          ::memcpy(large_ptr, short_ptr, sizeof_storage);

Modified: branches/release/boost/container/detail/workaround.hpp
==============================================================================
--- branches/release/boost/container/detail/workaround.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/detail/workaround.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -35,6 +35,12 @@
    #define BOOST_CONTAINER_UNIMPLEMENTED_PACK_EXPANSION_TO_FIXED_LIST
 #endif
 
+#if !defined(BOOST_FALLTHOUGH)
+ #define BOOST_CONTAINER_FALLTHOUGH
+#else
+ #define BOOST_CONTAINER_FALLTHOUGH BOOST_FALLTHOUGH;
+#endif
+
 //Macros for documentation purposes. For code, expands to the argument
 #define BOOST_CONTAINER_IMPDEF(TYPE) TYPE
 #define BOOST_CONTAINER_SEEDOC(TYPE) TYPE

Modified: branches/release/boost/container/flat_map.hpp
==============================================================================
--- branches/release/boost/container/flat_map.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/flat_map.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -84,8 +84,10 @@
 //! This means that inserting a new element into a flat_map invalidates
 //! previous iterators and references
 //!
-//! Erasing an element of a flat_map invalidates iterators and references
+//! Erasing an element invalidates iterators and references
 //! pointing to elements that come after (their keys are bigger) the erased element.
+//!
+//! This container provides random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< Key, T> > >
 #else
@@ -173,7 +175,15 @@
    //!
    //! <b>Complexity</b>: Constant.
    explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
- : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) {}
+ : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
+ {}
+
+ //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit flat_map(const allocator_type& a)
+ : m_flat_tree(container_detail::force<impl_allocator_type>(a))
+ {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
@@ -939,6 +949,15 @@
 //!
 //! Allocator is the allocator to allocate the value_types
 //! (e.g. <i>allocator< std::pair<Key, T> ></i>).
+//!
+//! flat_multimap is similar to std::multimap but it's implemented like an ordered vector.
+//! This means that inserting a new element into a flat_map invalidates
+//! previous iterators and references
+//!
+//! Erasing an element invalidates iterators and references
+//! pointing to elements that come after (their keys are bigger) the erased element.
+//!
+//! This container provides random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< Key, T> > >
 #else
@@ -1024,7 +1043,15 @@
    //! <b>Complexity</b>: Constant.
    explicit flat_multimap(const Compare& comp,
                           const allocator_type& a = allocator_type())
- : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) { }
+ : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
+ {}
+
+ //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit flat_multimap(const allocator_type& a)
+ : m_flat_tree(container_detail::force<impl_allocator_type>(a))
+ {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
    //! and allocator, and inserts elements from the range [first ,last ).

Modified: branches/release/boost/container/flat_set.hpp
==============================================================================
--- branches/release/boost/container/flat_set.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/flat_set.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -51,9 +51,7 @@
 /// @endcond
 
 //! flat_set is a Sorted Associative Container that stores objects of type Key.
-//! flat_set is a Simple Associative Container, meaning that its value type,
-//! as well as its key type, is Key. It is also a Unique Associative Container,
-//! meaning that no two elements are the same.
+//! It is also a Unique Associative Container, meaning that no two elements are the same.
 //!
 //! flat_set is similar to std::set but it's implemented like an ordered vector.
 //! This means that inserting a new element into a flat_set invalidates
@@ -61,6 +59,8 @@
 //!
 //! Erasing an element of a flat_set invalidates iterators and references
 //! pointing to elements that come after (their keys are bigger) the erased element.
+//!
+//! This container provides random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
 #else
@@ -121,6 +121,13 @@
       : m_flat_tree(comp, a)
    {}
 
+ //! <b>Effects</b>: Constructs an empty flat_set using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit flat_set(const allocator_type& a)
+ : m_flat_tree(a)
+ {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
    //!
@@ -756,16 +763,17 @@
 /// @endcond
 
 //! flat_multiset is a Sorted Associative Container that stores objects of type Key.
-//! flat_multiset is a Simple Associative Container, meaning that its value type,
-//! as well as its key type, is Key.
-//! flat_Multiset can store multiple copies of the same key value.
+//!
+//! flat_multiset can store multiple copies of the same key value.
 //!
 //! flat_multiset is similar to std::multiset but it's implemented like an ordered vector.
 //! This means that inserting a new element into a flat_multiset invalidates
 //! previous iterators and references
 //!
-//! Erasing an element of a flat_multiset invalidates iterators and references
-//! pointing to elements that come after (their keys are equal or bigger) the erased element.
+//! Erasing an element invalidates iterators and references
+//! pointing to elements that come after (their keys are bigger) the erased element.
+//!
+//! This container provides random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
 #else
@@ -810,9 +818,21 @@
       : m_flat_tree()
    {}
 
+ //! <b>Effects</b>: Constructs an empty flat_multiset using the specified
+ //! comparison object and allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
    explicit flat_multiset(const Compare& comp,
                           const allocator_type& a = allocator_type())
- : m_flat_tree(comp, a) {}
+ : m_flat_tree(comp, a)
+ {}
+
+ //! <b>Effects</b>: Constructs an empty flat_multiset using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit flat_multiset(const allocator_type& a)
+ : m_flat_tree(a)
+ {}
 
    template <class InputIterator>
    flat_multiset(InputIterator first, InputIterator last,

Modified: branches/release/boost/container/list.hpp
==============================================================================
--- branches/release/boost/container/list.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/list.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -18,6 +18,8 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/container_fwd.hpp>
 #include <boost/container/detail/version_type.hpp>
+#include <boost/container/detail/iterators.hpp>
+#include <boost/container/detail/mpl.hpp>
 #include <boost/container/throw_exception.hpp>
 #include <boost/move/utility.hpp>
 #include <boost/move/iterator.hpp>
@@ -26,7 +28,6 @@
 #include <boost/container/detail/utilities.hpp>
 #include <boost/container/detail/algorithms.hpp>
 #include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/container/detail/mpl.hpp>
 #include <boost/intrusive/list.hpp>
 #include <boost/assert.hpp>
 #include <boost/container/detail/node_alloc_holder.hpp>
@@ -64,8 +65,16 @@
    list_node();
 
    public:
+ typedef T value_type;
    typedef typename list_hook<VoidPointer>::type hook_type;
+
    T m_data;
+
+ T &get_data()
+ { return this->m_data; }
+
+ const T &get_data() const
+ { return this->m_data; }
 };
 
 template<class Allocator>
@@ -89,105 +98,6 @@
    typedef container_type type ;
 };
 
-template<class T, class IIterator>
-class list_const_iterator
- : public std::iterator< std::bidirectional_iterator_tag, T
- , typename iiterator_types<T, IIterator>::difference_type
- , typename iiterator_types<T, IIterator>::const_pointer
- , typename iiterator_types<T, IIterator>::const_reference>
-{
- protected:
-
- IIterator m_it;
-
- public:
- typedef typename iiterator_types<T, IIterator>::const_pointer const_pointer;
- typedef typename iiterator_types<T, IIterator>::const_reference const_reference;
-
- //Constructors
- list_const_iterator()
- : m_it()
- {}
-
- explicit list_const_iterator(const IIterator &it)
- : m_it(it)
- {}
-
- //Pointer like operators
- const_reference operator*() const
- { return this->m_it->m_data; }
-
- const_pointer operator->() const
- { return ::boost::intrusive::pointer_traits<const_pointer>::pointer_to(this->m_it->m_data); }
-
- //Increment / Decrement
- list_const_iterator& operator++()
- { ++this->m_it; return *this; }
-
- list_const_iterator operator++(int)
- { IIterator tmp = this->m_it; ++*this; return list_const_iterator(tmp); }
-
- list_const_iterator& operator--()
- { --this->m_it; return *this; }
-
- list_const_iterator operator--(int)
- { IIterator tmp = this->m_it; --*this; return list_const_iterator(tmp); }
-
- //Comparison operators
- friend bool operator== (const list_const_iterator& l, const list_const_iterator& r)
- { return l.m_it == r.m_it; }
-
- friend bool operator!= (const list_const_iterator& l, const list_const_iterator& r)
- { return l.m_it != r.m_it; }
-
- const IIterator &get() const
- { return this->m_it; }
-};
-
-template<class T, class IIterator>
-class list_iterator
- : public list_const_iterator<T, IIterator>
-{
- private:
- typedef list_const_iterator<T, IIterator> const_iterator;
-
- public:
- typedef typename iiterator_types<T, IIterator>::pointer pointer;
- typedef typename iiterator_types<T, IIterator>::reference reference;
-
- //Constructors
- list_iterator()
- : const_iterator()
- {}
-
- explicit list_iterator(const IIterator &it)
- : const_iterator(it)
- {}
-
- //Pointer like operators
- reference operator*() const
- { return this->m_it->m_data; }
-
- pointer operator->() const
- { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->m_it->m_data); }
-
- //Increment / Decrement
- list_iterator& operator++()
- { ++this->m_it; return *this; }
-
- list_iterator operator++(int)
- { IIterator tmp = this->m_it; ++*this; return list_iterator(tmp); }
-
- list_iterator& operator--()
- { --this->m_it; return *this; }
-
- list_iterator operator--(int)
- { IIterator tmp = this->m_it; --*this; return list_iterator(tmp); }
-
- const IIterator &get() const
- { return this->m_it; }
-};
-
 } //namespace container_detail {
 /// @endcond
 
@@ -255,8 +165,8 @@
 
    BOOST_COPYABLE_AND_MOVABLE(list)
 
- typedef container_detail::list_iterator<T, typename Icont::iterator> iterator_impl;
- typedef container_detail::list_const_iterator<T, typename Icont::iterator>const_iterator_impl;
+ typedef container_detail::iterator<typename Icont::iterator, false> iterator_impl;
+ typedef container_detail::iterator<typename Icont::iterator, true> const_iterator_impl;
    /// @endcond
 
    public:
@@ -442,7 +352,6 @@
          }
          //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()));
          }

Modified: branches/release/boost/container/map.hpp
==============================================================================
--- branches/release/boost/container/map.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/map.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -138,6 +138,16 @@
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
    }
 
+ //! <b>Effects</b>: Constructs an empty map using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit map(const allocator_type& a)
+ : m_tree(a)
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
+ }
+
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
    //!
@@ -918,8 +928,7 @@
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
    }
 
- //! <b>Effects</b>: Constructs an empty multimap using the specified comparison
- //! object and allocator.
+ //! <b>Effects</b>: Constructs an empty multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
    explicit multimap(const Compare& comp, const allocator_type& a = allocator_type())
@@ -929,6 +938,17 @@
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
    }
 
+ //! <b>Effects</b>: Constructs an empty multimap using the specified comparison
+ //! object and allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit multimap(const allocator_type& a)
+ : m_tree(a)
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
+ }
+
    //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
    //! and allocator, and inserts elements from the range [first ,last ).
    //!

Modified: branches/release/boost/container/set.hpp
==============================================================================
--- branches/release/boost/container/set.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/set.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -113,6 +113,13 @@
       : m_tree(comp, a)
    {}
 
+ //! <b>Effects</b>: Constructs an empty set using the specified allocator object.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit set(const allocator_type& a)
+ : m_tree(a)
+ {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
    //!
@@ -737,6 +744,13 @@
       : m_tree(comp, a)
    {}
 
+ //! <b>Effects</b>: Constructs an empty multiset using the specified allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
+ explicit multiset(const allocator_type& a)
+ : m_tree(a)
+ {}
+
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object
    //! and allocator, and inserts elements from the range [first ,last ).
    //!

Modified: branches/release/boost/container/slist.hpp
==============================================================================
--- branches/release/boost/container/slist.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/slist.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -24,6 +24,7 @@
 #include <boost/move/detail/move_helpers.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/container/detail/utilities.hpp>
+#include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/type_traits/has_trivial_destructor.hpp>
@@ -69,8 +70,16 @@
    slist_node();
 
    public:
+ typedef T value_type;
    typedef typename slist_hook<VoidPointer>::type hook_type;
+
    T m_data;
+
+ T &get_data()
+ { return this->m_data; }
+
+ const T &get_data() const
+ { return this->m_data; }
 };
 
 template<class Allocator>
@@ -95,93 +104,6 @@
    typedef container_type type ;
 };
 
-template<class T, class IIterator>
-class slist_const_iterator
- : public std::iterator< std::forward_iterator_tag, T
- , typename iiterator_types<T, IIterator>::difference_type
- , typename iiterator_types<T, IIterator>::const_pointer
- , typename iiterator_types<T, IIterator>::const_reference>
-{
- protected:
-
- IIterator m_it;
-
- public:
- typedef typename iiterator_types<T, IIterator>::const_pointer const_pointer;
- typedef typename iiterator_types<T, IIterator>::const_reference const_reference;
-
- //Constructors
- slist_const_iterator()
- : m_it()
- {}
-
- explicit slist_const_iterator(const IIterator &it)
- : m_it(it)
- {}
-
- //Pointer like operators
- const_reference operator*() const
- { return this->m_it->m_data; }
-
- const_pointer operator->() const
- { return ::boost::intrusive::pointer_traits<const_pointer>::pointer_to(this->m_it->m_data); }
-
- //Increment / Decrement
- slist_const_iterator& operator++()
- { ++this->m_it; return *this; }
-
- slist_const_iterator operator++(int)
- { IIterator tmp = this->m_it; ++*this; return slist_const_iterator(tmp); }
-
- //Comparison operators
- friend bool operator== (const slist_const_iterator& l, const slist_const_iterator& r)
- { return l.m_it == r.m_it; }
-
- friend bool operator!= (const slist_const_iterator& l, const slist_const_iterator& r)
- { return l.m_it != r.m_it; }
-
- const IIterator &get() const
- { return this->m_it; }
-};
-
-template<class T, class IIterator>
-class slist_iterator
- : public slist_const_iterator<T, IIterator>
-{
- private:
- typedef slist_const_iterator<T, IIterator> const_iterator;
-
- public:
- typedef typename iiterator_types<T, IIterator>::pointer pointer;
- typedef typename iiterator_types<T, IIterator>::reference reference;
-
- //Constructors
- slist_iterator()
- : const_iterator()
- {}
-
- explicit slist_iterator(const IIterator &it)
- : const_iterator(it)
- {}
-
- //Pointer like operators
- reference operator*() const
- { return this->m_it->m_data; }
-
- pointer operator->() const
- { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->m_it->m_data); }
-
- //Increment / Decrement
- slist_iterator& operator++()
- { ++this->m_it; return *this; }
-
- slist_iterator operator++(int)
- { IIterator tmp = this->m_it; ++*this; return slist_iterator(tmp); }
-
- const IIterator &get() const
- { return this->m_it; }
-};
-
 } //namespace container_detail {
 
 /// @endcond
@@ -271,8 +193,8 @@
    };
 
    BOOST_COPYABLE_AND_MOVABLE(slist)
- typedef container_detail::slist_iterator<T, typename Icont::iterator> iterator_impl;
- typedef container_detail::slist_const_iterator<T, typename Icont::iterator>const_iterator_impl;
+ typedef container_detail::iterator<typename Icont::iterator, false> iterator_impl;
+ typedef container_detail::iterator<typename Icont::iterator, true > const_iterator_impl;
    /// @endcond
 
    public:
@@ -451,7 +373,6 @@
          }
          //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()));
          }

Modified: branches/release/boost/container/stable_vector.hpp
==============================================================================
--- branches/release/boost/container/stable_vector.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/stable_vector.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -88,7 +88,7 @@
    bool do_clear_;
 };
 
-template<typename VoidPointer, typename T>
+template<typename Pointer>
 struct node;
 
 template<class VoidPtr>
@@ -116,167 +116,172 @@
    node_base_ptr_ptr up;
 };
 
-template<typename VoidPointer, typename T>
+template<typename Pointer>
 struct node
- : public node_base<VoidPointer>
+ : public node_base
+ <typename ::boost::intrusive::pointer_traits<Pointer>::template
+ rebind_pointer<void>::type
+ >
 {
    private:
    node();
 
    public:
- T value;
+ typename ::boost::intrusive::pointer_traits<Pointer>::element_type value;
 };
 
-template<typename T, typename Reference, typename Pointer>
+template<typename Pointer, bool IsConst>
 class iterator
- : public std::iterator< std::random_access_iterator_tag
- , T
- , typename boost::intrusive::
- pointer_traits<Pointer>::difference_type
- , Pointer
- , Reference>
 {
- typedef boost::intrusive::
- pointer_traits<Pointer> ptr_traits;
- typedef typename ptr_traits::template
+ typedef boost::intrusive::pointer_traits<Pointer> non_const_ptr_traits;
+ public:
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef typename non_const_ptr_traits::element_type value_type;
+ typedef typename non_const_ptr_traits::difference_type difference_type;
+ typedef typename ::boost::container::container_detail::if_c
+ < IsConst
+ , typename non_const_ptr_traits::template
+ rebind_pointer<const value_type>::type
+ , Pointer
+ >::type pointer;
+ typedef typename ::boost::container::container_detail::if_c
+ < IsConst
+ , const value_type&
+ , value_type&
+ >::type reference;
+
+ private:
+ typedef typename non_const_ptr_traits::template
          rebind_pointer<void>::type void_ptr;
- typedef node<void_ptr, T> node_type;
+ typedef node<Pointer> node_type;
    typedef node_base<void_ptr> node_base_type;
- typedef typename ptr_traits::template
+ typedef typename non_const_ptr_traits::template
          rebind_pointer<node_type>::type node_ptr;
    typedef boost::intrusive::
       pointer_traits<node_ptr> node_ptr_traits;
- typedef typename ptr_traits::template
+ typedef typename non_const_ptr_traits::template
          rebind_pointer<node_base_type>::type node_base_ptr;
- typedef typename ptr_traits::template
+ typedef typename non_const_ptr_traits::template
          rebind_pointer<node_base_ptr>::type node_base_ptr_ptr;
- typedef typename ptr_traits::template
- rebind_pointer<T>::type friend_iterator_pointer;
 
- friend class iterator<T, const T, friend_iterator_pointer>;
+ node_ptr m_pn;
 
    public:
- typedef std::random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef typename ptr_traits::difference_type difference_type;
- typedef Pointer pointer;
- typedef Reference reference;
 
- iterator()
+ explicit iterator(node_ptr p) BOOST_CONTAINER_NOEXCEPT
+ : m_pn(p)
    {}
 
- explicit iterator(node_ptr p)
- : pn(p)
+ iterator() BOOST_CONTAINER_NOEXCEPT
    {}
 
- iterator(const iterator<T, T&, friend_iterator_pointer>& x)
- : pn(x.pn)
+ iterator(iterator<Pointer, false> const& other) BOOST_CONTAINER_NOEXCEPT
+ : m_pn(other.node_pointer())
    {}
 
- node_ptr &node_pointer()
- { return pn; }
+ node_ptr &node_pointer() BOOST_CONTAINER_NOEXCEPT
+ { return m_pn; }
 
- const node_ptr &node_pointer() const
- { return pn; }
+ const node_ptr &node_pointer() const BOOST_CONTAINER_NOEXCEPT
+ { return m_pn; }
 
    public:
    //Pointer like operators
- reference operator*() const
- { return pn->value; }
+ reference operator*() const BOOST_CONTAINER_NOEXCEPT
+ { return m_pn->value; }
 
- pointer operator->() const
- { return ptr_traits::pointer_to(this->operator*()); }
+ pointer operator->() const BOOST_CONTAINER_NOEXCEPT
+ {
+ typedef boost::intrusive::pointer_traits<pointer> ptr_traits;
+ return ptr_traits::pointer_to(this->operator*());
+ }
 
    //Increment / Decrement
- iterator& operator++()
+ iterator& operator++() BOOST_CONTAINER_NOEXCEPT
    {
- if(node_base_ptr_ptr p = this->pn->up){
+ if(node_base_ptr_ptr p = this->m_pn->up){
          ++p;
- this->pn = node_ptr_traits::static_cast_from(*p);
+ this->m_pn = node_ptr_traits::static_cast_from(*p);
       }
       return *this;
    }
 
- iterator operator++(int)
+ iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
    { iterator tmp(*this); ++*this; return iterator(tmp); }
 
- iterator& operator--()
+ iterator& operator--() BOOST_CONTAINER_NOEXCEPT
    {
- if(node_base_ptr_ptr p = this->pn->up){
+ if(node_base_ptr_ptr p = this->m_pn->up){
          --p;
- this->pn = node_ptr_traits::static_cast_from(*p);
+ this->m_pn = node_ptr_traits::static_cast_from(*p);
       }
       return *this;
    }
 
- iterator operator--(int)
+ iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
    { iterator tmp(*this); --*this; return iterator(tmp); }
 
- reference operator[](difference_type off) const
+ reference operator[](difference_type off) const BOOST_CONTAINER_NOEXCEPT
    {
       iterator tmp(*this);
       tmp += off;
       return *tmp;
    }
 
- iterator& operator+=(difference_type off)
+ iterator& operator+=(difference_type off) BOOST_CONTAINER_NOEXCEPT
    {
- if(node_base_ptr_ptr p = this->pn->up){
+ if(node_base_ptr_ptr p = this->m_pn->up){
          p += off;
- this->pn = node_ptr_traits::static_cast_from(*p);
+ this->m_pn = node_ptr_traits::static_cast_from(*p);
       }
       return *this;
    }
 
- friend iterator operator+(const iterator &left, difference_type off)
+ friend iterator operator+(const iterator &left, difference_type off) BOOST_CONTAINER_NOEXCEPT
    {
       iterator tmp(left);
       tmp += off;
       return tmp;
    }
 
- friend iterator operator+(difference_type off, const iterator& right)
+ friend iterator operator+(difference_type off, const iterator& right) BOOST_CONTAINER_NOEXCEPT
    {
       iterator tmp(right);
       tmp += off;
       return tmp;
    }
 
- iterator& operator-=(difference_type off)
+ iterator& operator-=(difference_type off) BOOST_CONTAINER_NOEXCEPT
    { *this += -off; return *this; }
 
- friend iterator operator-(const iterator &left, difference_type off)
+ friend iterator operator-(const iterator &left, difference_type off) BOOST_CONTAINER_NOEXCEPT
    {
       iterator tmp(left);
       tmp -= off;
       return tmp;
    }
 
- friend difference_type operator-(const iterator& left, const iterator& right)
- {
- return left.pn->up - right.pn->up;
- }
+ friend difference_type operator-(const iterator& left, const iterator& right) BOOST_CONTAINER_NOEXCEPT
+ { return left.m_pn->up - right.m_pn->up; }
 
    //Comparison operators
- friend bool operator== (const iterator& l, const iterator& r)
- { return l.pn == r.pn; }
-
- friend bool operator!= (const iterator& l, const iterator& r)
- { return l.pn != r.pn; }
+ friend bool operator== (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn == r.m_pn; }
 
- friend bool operator< (const iterator& l, const iterator& r)
- { return l.pn->up < r.pn->up; }
+ friend bool operator!= (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn != r.m_pn; }
 
- friend bool operator<= (const iterator& l, const iterator& r)
- { return l.pn->up <= r.pn->up; }
+ friend bool operator< (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn->up < r.m_pn->up; }
 
- friend bool operator> (const iterator& l, const iterator& r)
- { return l.pn->up > r.pn->up; }
+ friend bool operator<= (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn->up <= r.m_pn->up; }
 
- friend bool operator>= (const iterator& l, const iterator& r)
- { return l.pn->up >= r.pn->up; }
+ friend bool operator> (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn->up > r.m_pn->up; }
 
- node_ptr pn;
+ friend bool operator>= (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
+ { return l.m_pn->up >= r.m_pn->up; }
 };
 
 template<class VoidPtr, class VoidAllocator>
@@ -354,7 +359,6 @@
       }
    }
 
-
    #ifdef STABLE_VECTOR_ENABLE_INVARIANT_CHECKING
    static bool invariants(index_type &index)
    {
@@ -431,8 +435,10 @@
 {
    ///@cond
    typedef allocator_traits<Allocator> allocator_traits_type;
- typedef typename boost::intrusive::pointer_traits
- <typename allocator_traits_type::pointer>::
+ typedef boost::intrusive::
+ pointer_traits
+ <typename allocator_traits_type::pointer> ptr_traits;
+ typedef typename ptr_traits::
          template rebind_pointer<void>::type void_ptr;
    typedef typename allocator_traits_type::
       template portable_rebind_alloc
@@ -451,10 +457,8 @@
    typedef typename index_traits_type::index_iterator index_iterator;
    typedef typename index_traits_type::
       const_index_iterator const_index_iterator;
- typedef boost::intrusive::
- pointer_traits
- <typename allocator_traits_type::pointer> ptr_traits;
- typedef stable_vector_detail::node<void_ptr, T> node_type;
+ typedef stable_vector_detail::node
+ <typename ptr_traits::pointer> node_type;
    typedef typename ptr_traits::template
       rebind_pointer<node_type>::type node_ptr;
    typedef boost::intrusive::
@@ -495,13 +499,11 @@
 
    friend class stable_vector_detail::clear_on_destroy<stable_vector>;
    typedef stable_vector_detail::iterator
- < T
- , typename allocator_traits<Allocator>::reference
- , typename allocator_traits<Allocator>::pointer> iterator_impl;
+ < typename allocator_traits<Allocator>::pointer
+ , false> iterator_impl;
    typedef stable_vector_detail::iterator
- < T
- , typename allocator_traits<Allocator>::const_reference
- , typename allocator_traits<Allocator>::const_pointer> const_iterator_impl;
+ < typename allocator_traits<Allocator>::pointer
+ , false> const_iterator_impl;
    ///@endcond
    public:
 

Modified: branches/release/boost/container/static_vector.hpp
==============================================================================
--- branches/release/boost/container/static_vector.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/static_vector.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -81,8 +81,11 @@
  * possible.
  *
  * @par Error Handling
- * Insertion beyond the capacity and out of bounds errors results in calling throw_bad_alloc().
- * The reason for this is because unlike vectors, static_vector does not perform allocation.
+ * Insertion beyond the capacity result in throwing std::bad_alloc() if exceptions are enabled or
+ * calling throw_bad_alloc() if not enabled.
+ *
+ * std::out_of_range is thrown if out of bound access is performed in `at()` if exceptions are
+ * enabled, throw_out_of_range() if not enabled.
  *
  * @tparam Value The type of element that will be stored.
  * @tparam Capacity The maximum number of elements static_vector can store, fixed at compile time.

Modified: branches/release/boost/container/vector.hpp
==============================================================================
--- branches/release/boost/container/vector.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/boost/container/vector.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -61,20 +61,27 @@
 
 #ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 
-//! Const vector_iterator used to iterate through a vector.
-template <class Pointer>
-class vector_const_iterator
+template <class Pointer, bool IsConst>
+class vec_iterator
 {
    public:
         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 boost::intrusive::pointer_traits<Pointer>::template
- rebind_pointer<const value_type>::type pointer;
- typedef const value_type& reference;
+ 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;
 
    /// @cond
- protected:
+ private:
    Pointer m_ptr;
 
    public:
@@ -84,7 +91,7 @@
    Pointer &get_ptr() BOOST_CONTAINER_NOEXCEPT
    { return m_ptr; }
 
- explicit vector_const_iterator(Pointer ptr) BOOST_CONTAINER_NOEXCEPT
+ explicit vec_iterator(Pointer ptr) BOOST_CONTAINER_NOEXCEPT
       : m_ptr(ptr)
    {}
    /// @endcond
@@ -92,7 +99,7 @@
    public:
 
    //Constructors
- vector_const_iterator() BOOST_CONTAINER_NOEXCEPT
+ vec_iterator() BOOST_CONTAINER_NOEXCEPT
       #ifndef NDEBUG
       : m_ptr()
       #else
@@ -100,139 +107,80 @@
       #endif
    {}
 
+ vec_iterator(vec_iterator<Pointer, false> const& other) BOOST_CONTAINER_NOEXCEPT
+ : m_ptr(other.get_ptr())
+ {}
+
    //Pointer like operators
    reference operator*() const BOOST_CONTAINER_NOEXCEPT
    { return *m_ptr; }
 
- const value_type * operator->() const BOOST_CONTAINER_NOEXCEPT
- { return container_detail::to_raw_pointer(m_ptr); }
+ pointer operator->() const BOOST_CONTAINER_NOEXCEPT
+ { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*()); }
 
    reference operator[](difference_type off) const BOOST_CONTAINER_NOEXCEPT
    { return m_ptr[off]; }
 
    //Increment / Decrement
- vector_const_iterator& operator++() BOOST_CONTAINER_NOEXCEPT
+ vec_iterator& operator++() BOOST_CONTAINER_NOEXCEPT
    { ++m_ptr; return *this; }
 
- vector_const_iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
- { return vector_const_iterator(m_ptr++); }
+ vec_iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
+ { return vec_iterator(m_ptr++); }
 
- vector_const_iterator& operator--() BOOST_CONTAINER_NOEXCEPT
+ vec_iterator& operator--() BOOST_CONTAINER_NOEXCEPT
    { --m_ptr; return *this; }
 
- vector_const_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
- { return vector_const_iterator(m_ptr--); }
+ vec_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
+ { return vec_iterator(m_ptr--); }
 
    //Arithmetic
- vector_const_iterator& operator+=(difference_type off) BOOST_CONTAINER_NOEXCEPT
+ vec_iterator& operator+=(difference_type off) BOOST_CONTAINER_NOEXCEPT
    { m_ptr += off; return *this; }
 
- vector_const_iterator& operator-=(difference_type off) BOOST_CONTAINER_NOEXCEPT
+ vec_iterator& operator-=(difference_type off) BOOST_CONTAINER_NOEXCEPT
    { m_ptr -= off; return *this; }
 
- friend vector_const_iterator operator+(const vector_const_iterator &x, difference_type off) BOOST_CONTAINER_NOEXCEPT
- { return vector_const_iterator(x.m_ptr+off); }
+ friend vec_iterator operator+(const vec_iterator &x, difference_type off) BOOST_CONTAINER_NOEXCEPT
+ { return vec_iterator(x.m_ptr+off); }
 
- friend vector_const_iterator operator+(difference_type off, vector_const_iterator right) BOOST_CONTAINER_NOEXCEPT
+ friend vec_iterator operator+(difference_type off, vec_iterator right) BOOST_CONTAINER_NOEXCEPT
    { right.m_ptr += off; return right; }
 
- friend vector_const_iterator operator-(vector_const_iterator left, difference_type off) BOOST_CONTAINER_NOEXCEPT
+ friend vec_iterator operator-(vec_iterator left, difference_type off) BOOST_CONTAINER_NOEXCEPT
    { left.m_ptr -= off; return left; }
 
- friend difference_type operator-(const vector_const_iterator &left, const vector_const_iterator& right) BOOST_CONTAINER_NOEXCEPT
+ friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) BOOST_CONTAINER_NOEXCEPT
    { return left.m_ptr - right.m_ptr; }
 
    //Comparison operators
- friend bool operator== (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator== (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr == r.m_ptr; }
 
- friend bool operator!= (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator!= (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr != r.m_ptr; }
 
- friend bool operator< (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator< (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr < r.m_ptr; }
 
- friend bool operator<= (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator<= (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr <= r.m_ptr; }
 
- friend bool operator> (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator> (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr > r.m_ptr; }
 
- friend bool operator>= (const vector_const_iterator& l, const vector_const_iterator& r) BOOST_CONTAINER_NOEXCEPT
+ friend bool operator>= (const vec_iterator& l, const vec_iterator& r) BOOST_CONTAINER_NOEXCEPT
    { return l.m_ptr >= r.m_ptr; }
 };
 
-//! Iterator used to iterate through a vector
-template <class Pointer>
-class vector_iterator
- : public vector_const_iterator<Pointer>
-{
- typedef vector_const_iterator<Pointer> base_t;
- public:
- explicit vector_iterator(Pointer ptr) BOOST_CONTAINER_NOEXCEPT
- : base_t(ptr)
- {}
-
- public:
- 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 Pointer pointer;
- typedef value_type& reference;
-
- //Constructors
- vector_iterator() BOOST_CONTAINER_NOEXCEPT
- : base_t()
- {}
-
- //Pointer like operators
- reference operator*() const BOOST_CONTAINER_NOEXCEPT
- { return *this->m_ptr; }
-
- value_type* operator->() const BOOST_CONTAINER_NOEXCEPT
- { return container_detail::to_raw_pointer(this->m_ptr); }
-
- reference operator[](difference_type off) const BOOST_CONTAINER_NOEXCEPT
- { return this->m_ptr[off]; }
-
- //Increment / Decrement
- vector_iterator& operator++() BOOST_CONTAINER_NOEXCEPT
- { ++this->m_ptr; return *this; }
-
- vector_iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
- { return vector_iterator(this->m_ptr++); }
-
- vector_iterator& operator--() BOOST_CONTAINER_NOEXCEPT
- { --this->m_ptr; return *this; }
-
- vector_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
- { return vector_iterator(this->m_ptr--); }
-
- // Arithmetic
- vector_iterator& operator+=(difference_type off) BOOST_CONTAINER_NOEXCEPT
- { this->m_ptr += off; return *this; }
-
- vector_iterator& operator-=(difference_type off) BOOST_CONTAINER_NOEXCEPT
- { this->m_ptr -= off; return *this; }
-
- friend vector_iterator operator+(vector_iterator left, difference_type off) BOOST_CONTAINER_NOEXCEPT
- { left.m_ptr += off; return left; }
-
- friend vector_iterator operator+(difference_type off, vector_iterator right) BOOST_CONTAINER_NOEXCEPT
- { right.m_ptr += off; return right; }
-
- friend vector_iterator operator-(vector_iterator left, difference_type off) BOOST_CONTAINER_NOEXCEPT
- { left.m_ptr -= off; return left; }
-};
-
 } //namespace container_detail {
 
-template<class Pointer>
-const Pointer &vector_iterator_get_ptr(const container_detail::vector_const_iterator<Pointer> &it) BOOST_CONTAINER_NOEXCEPT
+template<class Pointer, bool IsConst>
+const Pointer &vector_iterator_get_ptr(const container_detail::vec_iterator<Pointer, IsConst> &it) BOOST_CONTAINER_NOEXCEPT
 { return it.get_ptr(); }
 
-template<class Pointer>
-Pointer &get_ptr(container_detail::vector_const_iterator<Pointer> &it) BOOST_CONTAINER_NOEXCEPT
+template<class Pointer, bool IsConst>
+Pointer &get_ptr(container_detail::vec_iterator<Pointer, IsConst> &it) BOOST_CONTAINER_NOEXCEPT
 { return it.get_ptr(); }
 
 namespace container_detail {
@@ -251,7 +199,7 @@
    typedef typename pointer_traits_t
       ::template rebind_pointer<non_const_element_type>::type return_type;
 
- static return_type get_ptr(const const_pointer &ptr)
+ static return_type get_ptr(const const_pointer &ptr) BOOST_CONTAINER_NOEXCEPT
    { return boost::intrusive::pointer_traits<return_type>::const_cast_from(ptr); }
 };
 
@@ -259,7 +207,7 @@
 struct vector_get_ptr_pointer_to_non_const<Pointer, false>
 {
    typedef const Pointer & return_type;
- static return_type get_ptr(const Pointer &ptr)
+ static return_type get_ptr(const Pointer &ptr) BOOST_CONTAINER_NOEXCEPT
    { return ptr; }
 };
 
@@ -565,6 +513,7 @@
 };
 
 } //namespace container_detail {
+
 /// @endcond
 
 //! \class vector
@@ -585,11 +534,17 @@
    typedef container_detail::integral_constant
       <unsigned, boost::container::container_detail::version
          <Allocator>::value > alloc_version;
- boost::container::container_detail::vector_alloc_holder<Allocator, alloc_version> m_holder;
- typedef container_detail::vector_alloc_holder<Allocator> base_t;
- typedef allocator_traits<Allocator> allocator_traits_type;
+ boost::container::container_detail::vector_alloc_holder
+ <Allocator, alloc_version> m_holder;
+ typedef allocator_traits<Allocator> allocator_traits_type;
    template <class U, class UAllocator>
    friend class vector;
+
+ typedef typename ::boost::container::allocator_traits
+ <Allocator>::pointer pointer_impl;
+ typedef container_detail::vec_iterator<pointer_impl, false> iterator_impl;
+ typedef container_detail::vec_iterator<pointer_impl, true > const_iterator_impl;
+
    /// @endcond
    public:
    //////////////////////////////////////////////
@@ -611,8 +566,8 @@
    typedef BOOST_CONTAINER_IMPDEF(pointer) iterator;
    typedef BOOST_CONTAINER_IMPDEF(const_pointer) const_iterator;
    #else
- typedef BOOST_CONTAINER_IMPDEF(container_detail::vector_iterator<pointer>) iterator;
- typedef BOOST_CONTAINER_IMPDEF(container_detail::vector_const_iterator<pointer>) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
    #endif
    typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;

Modified: branches/release/libs/container/doc/container.qbk
==============================================================================
--- branches/release/libs/container/doc/container.qbk Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/doc/container.qbk 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -1,5 +1,5 @@
 [/
- / Copyright (c) 2009-2012 Ion Gazta\u00F1aga
+ / Copyright (c) 2009-2013 Ion Gazta\u00F1aga
  /
  / 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)
@@ -8,7 +8,7 @@
 [library Boost.Container
     [quickbook 1.5]
     [authors [Gaztanaga, Ion]]
- [copyright 2009-2012 Ion Gaztanaga]
+ [copyright 2009-2013 Ion Gaztanaga]
     [id container]
     [dirname container]
     [purpose Containers library]
@@ -67,6 +67,8 @@
 
 [endsect]
 
+[section:main_features Main features]
+
 [section:move_emplace Efficient insertion]
 
 Move semantics and placement insertion are two features brought by C++11 containers
@@ -189,6 +191,45 @@
 
 [endsect]
 
+[section:scary_iterators SCARY iterators]
+
+The paper N2913, titled [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2913.pdf,
+SCARY Iterator Assignment and Initialization], proposed a requirement that a standard container's
+iterator types have no dependency on any type argument apart from the container's `value_type`,
+`difference_type`, `pointer type`, and `const_pointer` type. In particular, according to the proposal,
+the types of a standard container's iterators should not depend on the container's `key_compare`,
+`hasher`, `key_equal`, or `allocator` types.
+
+That paper demonstrated that SCARY operations were crucial to the performant implementation of common
+design patterns using STL components. It showed that implementations that support SCARY operations reduce
+object code bloat by eliminating redundant specializations of iterator and algorithm templates.
+
+[*Boost.Container] containers implement SCARY iterators so the iterator type of a container is only dependent
+on the `allocator_traits<allocator_type>::pointer` type (the pointer type of the `value_type` to be inserted
+in the container). Reference types and all other typedefs are deduced from the pointer type using the
+C++11 `pointer_traits` utility. This leads to lower code bloat in algorithms and classes templated on
+iterators.
+
+[endsect]
+
+[section:other_features Other features]
+
+* Default constructors don't allocate memory which improves performance and
+ usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
+
+* Small string optimization for [classref boost::container::basic_string basic_string],
+ with an internal buffer of 11/23 bytes (32/64 bit systems)
+ [*without] increasing the usual `sizeof` of the string (3 words).
+
+* `[multi]set/map` containers are size optimized embedding the color bit of the red-black tree nodes
+ in the parent pointer.
+
+* `[multi]set/map` containers use no recursive functions so stack problems are avoided.
+
+[endsect]
+
+[endsect]
+
 [section:exception_handling Boost.Container and C++ exceptions]
 
 In some environments, such as game development or embedded systems, C++ exceptions are disabled or a customized error handling is needed.
@@ -375,7 +416,8 @@
 attributes:
 
 * Faster lookup than standard associative containers
-* Much faster iteration than standard associative containers
+* Much faster iteration than standard associative containers.
+ Random-access iterators instead of bidirectional iterators.
 * Less memory consumption for small objects (and for big objects if `shrink_to_fit` is used)
 * Improved cache performance (data is stored in contiguous memory)
 * Non-stable iterators (iterators are invalidated when inserting and erasing elements)
@@ -524,7 +566,7 @@
 [*Boost.Container] implements its own `scoped_allocator_adaptor` class and [*backports this feature also
 to C++03 compilers]. Due to C++03 limitations, in those compilers
 the allocator propagation implemented by `scoped_allocator_adaptor::construct` functions
-will be based on traits([classref boost::container::constructible_with_allocator_suffix constructible_with_allocator_suffix]
+will be based on traits ([classref boost::container::constructible_with_allocator_suffix constructible_with_allocator_suffix]
 and [classref boost::container::constructible_with_allocator_prefix constructible_with_allocator_prefix])
 proposed in [@http://www.open-std.org/jtc1/sc22/WG21/docs/papers/2008/n2554.pdf
 N2554: The Scoped Allocator Model (Rev 2) proposal]. In conforming C++11 compilers or compilers supporting SFINAE
@@ -581,22 +623,6 @@
 
 [endsect]
 
-[section:other_features Other features]
-
-* Default constructors don't allocate memory which improves performance and
- usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw).
-
-* Small string optimization for [classref boost::container::basic_string basic_string],
- with an internal buffer of 11/23 bytes (32/64 bit systems)
- [*without] increasing the usual `sizeof` of the string (3 words).
-
-* `[multi]set/map` containers are size optimized embedding the color bit of the red-black tree nodes
- in the parent pointer.
-
-* `[multi]set/map` containers use no recursive functions so stack problems are avoided.
-
-[endsect]
-
 [section:history_and_reasons History and reasons to use Boost.Container]
 
 [section:boost_container_history Boost.Container history]
@@ -688,6 +714,16 @@
 
 [section:release_notes Release Notes]
 
+[section:release_notes_boost_1_55_00 Boost 1.55 Release]
+
+* Implemented [link container.main_features.scary_iterators SCARY iterators].
+
+* Fixed bugs [@https://svn.boost.org/trac/boost/ticket/8892 #8892],
+ [@https://svn.boost.org/trac/boost/ticket/8473 #8473],
+ [@https://svn.boost.org/trac/boost/ticket/8269 #8269].
+
+[endsect]
+
 [section:release_notes_boost_1_54_00 Boost 1.54 Release]
 
 * Added experimental `static_vector` class, based on Andrew Hundt's and Adam Wulkiewicz's

Modified: branches/release/libs/container/test/check_equal_containers.hpp
==============================================================================
--- branches/release/libs/container/test/check_equal_containers.hpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/check_equal_containers.hpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -48,8 +48,6 @@
    if(boostcont->size() != stdcont->size())
       return false;
 
- typedef typename MyBoostCont::value_type value_type;
-
    typename MyBoostCont::const_iterator itboost(boostcont->begin()), itboostend(boostcont->end());
    typename MyStdCont::const_iterator itstd(stdcont->begin());
    typename MyStdCont::size_type dist = (typename MyStdCont::size_type)std::distance(itboost, itboostend);

Modified: branches/release/libs/container/test/flat_tree_test.cpp
==============================================================================
--- branches/release/libs/container/test/flat_tree_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/flat_tree_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -475,6 +475,13 @@
 {
    using namespace boost::container::test;
 
+ //Allocator argument container
+ {
+ flat_set<int> set_((std::allocator<int>()));
+ flat_multiset<int> multiset_((std::allocator<int>()));
+ flat_map<int, int> map_((std::allocator<std::pair<int, int> >()));
+ flat_multimap<int, int> multimap_((std::allocator<std::pair<int, int> >()));
+ }
    //Now test move semantics
    {
       test_move<flat_set<recursive_flat_set> >();

Modified: branches/release/libs/container/test/list_test.cpp
==============================================================================
--- branches/release/libs/container/test/list_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/list_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -34,10 +34,10 @@
 
 namespace container_detail {
 
-template class list_const_iterator
- <int, intrusive_list_type< std::allocator<int> >::container_type::iterator >;
-template class list_iterator
- <int, intrusive_list_type< std::allocator<int> >::container_type::iterator>;
+template class iterator
+ <intrusive_list_type< std::allocator<int> >::container_type::iterator, true >;
+template class iterator
+ <intrusive_list_type< std::allocator<int> >::container_type::iterator, false>;
 
 }
 

Modified: branches/release/libs/container/test/slist_test.cpp
==============================================================================
--- branches/release/libs/container/test/slist_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/slist_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -31,15 +31,6 @@
 template class boost::container::slist<test::movable_and_copyable_int,
    std::allocator<test::movable_and_copyable_int> >;
 
-namespace container_detail {
-
-template class slist_const_iterator
- <int, intrusive_slist_type< std::allocator<int> >::container_type::iterator >;
-template class slist_iterator
- <int, intrusive_slist_type< std::allocator<int> >::container_type::iterator>;
-
-}
-
 }}
 
 typedef slist<int> MyList;

Modified: branches/release/libs/container/test/stable_vector_test.cpp
==============================================================================
--- branches/release/libs/container/test/stable_vector_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/stable_vector_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -41,10 +41,10 @@
 
 namespace stable_vector_detail{
 
-template class iterator< int, int &, int *>;
-template class iterator< int, const int &, const int *>;
+template class iterator<int*, false>;
+template class iterator<int*, true >;
 
-}
+} //namespace stable_vector_detail{
 
 }}
 

Modified: branches/release/libs/container/test/tree_test.cpp
==============================================================================
--- branches/release/libs/container/test/tree_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/tree_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -247,6 +247,13 @@
       map<recursive_map, recursive_map> map_;
       multimap<recursive_multimap, recursive_multimap> multimap_;
    }
+ //Allocator argument container
+ {
+ set<int> set_((std::allocator<int>()));
+ multiset<int> multiset_((std::allocator<int>()));
+ map<int, int> map_((std::allocator<std::pair<const int, int> >()));
+ multimap<int, int> multimap_((std::allocator<std::pair<const int, int> >()));
+ }
    //Now test move semantics
    {
       test_move<set<recursive_set> >();
@@ -255,7 +262,6 @@
       test_move<multimap<recursive_multimap, recursive_multimap> >();
    }
 
- //using namespace boost::container::detail;
 
    if(0 != test::set_test<MyBoostSet
                         ,MyStdSet

Modified: branches/release/libs/container/test/vector_test.cpp
==============================================================================
--- branches/release/libs/container/test/vector_test.cpp Sat Aug 24 06:34:37 2013 (r85442)
+++ branches/release/libs/container/test/vector_test.cpp 2013-08-24 06:41:09 EDT (Sat, 24 Aug 2013) (r85443)
@@ -43,8 +43,8 @@
 
 #ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 
-template class vector_const_iterator<int*>;
-template class vector_iterator<int*>;
+template class vec_iterator<int*, true >;
+template class vec_iterator<int*, false>;
 
 #endif //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk