Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r80806 - in branches/release: boost/container boost/container/detail libs/container libs/container/doc libs/container/proj libs/container/test
From: igaztanaga_at_[hidden]
Date: 2012-10-01 07:32:07

Next message: matias.capeletto_at_[hidden]: "[Boost-commit] svn:boost r80807 - in trunk/boost/bimap: . detail relation"
Previous message: eric_at_[hidden]: "[Boost-commit] svn:boost r80805 - in branches/release: . libs libs/phoenix/test/algorithm"

Author: igaztanaga
Date: 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
New Revision: 80806
URL: http://svn.boost.org/trac/boost/changeset/80806

Log:
Merge from trunk
Properties modified:
   branches/release/boost/container/ (props changed)
   branches/release/libs/container/ (props changed)
Text files modified:
   branches/release/boost/container/container_fwd.hpp | 52 +-
   branches/release/boost/container/deque.hpp | 116 ++--
   branches/release/boost/container/detail/flat_tree.hpp | 24
   branches/release/boost/container/detail/tree.hpp | 10
   branches/release/boost/container/detail/utilities.hpp | 30 -
   branches/release/boost/container/flat_map.hpp | 875 +++++++++++++++++++++-----------------
   branches/release/boost/container/flat_set.hpp | 884 +++++++++++++++++++++------------------
   branches/release/boost/container/list.hpp | 129 ++--
   branches/release/boost/container/map.hpp | 782 +++++++++++++++++++---------------
   branches/release/boost/container/scoped_allocator.hpp | 32
   branches/release/boost/container/set.hpp | 730 ++++++++++++++++++--------------
   branches/release/boost/container/slist.hpp | 91 +--
   branches/release/boost/container/stable_vector.hpp | 279 +++++------
   branches/release/boost/container/string.hpp | 319 +++++--------
   branches/release/boost/container/vector.hpp | 153 +++---
   branches/release/libs/container/doc/Jamfile.v2 | 4
   branches/release/libs/container/doc/container.qbk | 3
   branches/release/libs/container/proj/to-do.txt | 15
   branches/release/libs/container/test/string_test.cpp | 22
   19 files changed, 2369 insertions(+), 2181 deletions(-)

Modified: branches/release/boost/container/container_fwd.hpp
==============================================================================
--- branches/release/boost/container/container_fwd.hpp (original)
+++ branches/release/boost/container/container_fwd.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -49,85 +49,85 @@

//vector class
template <class T
- ,class A = std::allocator<T> >
+ ,class Allocator = std::allocator<T> >
class vector;

//vector class
template <class T
- ,class A = std::allocator<T> >
+ ,class Allocator = std::allocator<T> >
class stable_vector;

//vector class
template <class T
- ,class A = std::allocator<T> >
+ ,class Allocator = std::allocator<T> >
class deque;

//list class
template <class T
- ,class A = std::allocator<T> >
+ ,class Allocator = std::allocator<T> >
class list;

//slist class
template <class T
- ,class A = std::allocator<T> >
+ ,class Allocator = std::allocator<T> >
class slist;

//set class
-template <class T
- ,class Pred = std::less<T>
- ,class A = std::allocator<T> >
+template <class Key
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<Key> >
class set;

//multiset class
-template <class T
- ,class Pred = std::less<T>
- ,class A = std::allocator<T> >
+template <class Key
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<Key> >
class multiset;

//map class
template <class Key
 ,class T
- ,class Pred = std::less<Key>
- ,class A = std::allocator<std::pair<const Key, T> > >
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<std::pair<const Key, T> > >
class map;

//multimap class
template <class Key
 ,class T
- ,class Pred = std::less<Key>
- ,class A = std::allocator<std::pair<const Key, T> > >
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<std::pair<const Key, T> > >
class multimap;

//flat_set class
-template <class T
- ,class Pred = std::less<T>
- ,class A = std::allocator<T> >
+template <class Key
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<Key> >
class flat_set;

//flat_multiset class
-template <class T
- ,class Pred = std::less<T>
- ,class A = std::allocator<T> >
+template <class Key
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<Key> >
class flat_multiset;

//flat_map class
template <class Key
 ,class T
- ,class Pred = std::less<Key>
- ,class A = std::allocator<std::pair<Key, T> > >
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<std::pair<Key, T> > >
class flat_map;

//flat_multimap class
template <class Key
 ,class T
- ,class Pred = std::less<Key>
- ,class A = std::allocator<std::pair<Key, T> > >
+ ,class Compare = std::less<Key>
+ ,class Allocator = std::allocator<std::pair<Key, T> > >
class flat_multimap;

//basic_string class
template <class CharT
 ,class Traits = std::char_traits<CharT>
- ,class A = std::allocator<CharT> >
+ ,class Allocator = std::allocator<CharT> >
class basic_string;

//! Type used to tag that the input range is

Modified: branches/release/boost/container/deque.hpp
==============================================================================
--- branches/release/boost/container/deque.hpp (original)
+++ branches/release/boost/container/deque.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -67,17 +67,17 @@

/// @cond
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
class deque;

-template <class T, class A>
+template <class T, class Allocator>
struct deque_value_traits
{
 typedef T value_type;
- typedef A allocator_type;
+ typedef Allocator allocator_type;
 static const bool trivial_dctr = boost::has_trivial_destructor<value_type>::value;
 static const bool trivial_dctr_after_move = false;
 //::boost::has_trivial_destructor_after_move<value_type>::value || trivial_dctr;
@@ -96,12 +96,12 @@
// 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 A>
+template <class T, class Allocator>
class deque_base
{
 BOOST_COPYABLE_AND_MOVABLE(deque_base)
 public:
- typedef allocator_traits<A> val_alloc_traits_type;
+ 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;
@@ -117,13 +117,13 @@
 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 A allocator_type;
+ typedef Allocator allocator_type;
 typedef allocator_type stored_allocator_type;
 typedef val_alloc_size size_type;

 protected:

- typedef deque_value_traits<T, A> traits_t;
+ typedef deque_value_traits<T, Allocator> traits_t;
 typedef ptr_alloc_t map_allocator_type;

 static size_type s_buffer_size() { return deque_buf_size(sizeof(T)); }
@@ -163,7 +163,7 @@
 // [map, map + map_size) is a valid, non-empty range.
 // [start.node, finish.node] is a valid range contained within
 // [map, map + map_size).
- // A pointer in the range [map, map + map_size) points to an allocated node
+ // 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,
@@ -171,7 +171,7 @@
 val_alloc_cptr, val_alloc_cref>
 {
 public:
- static size_type s_buffer_size() { return deque_base<T, A>::s_buffer_size(); }
+ 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;
@@ -182,8 +182,8 @@
 typedef ptr_alloc_ptr index_pointer;
 typedef const_iterator self_t;

- friend class deque<T, A>;
- friend class deque_base<T, A>;
+ friend class deque<T, Allocator>;
+ friend class deque_base<T, Allocator>;

 protected:
 val_alloc_ptr m_cur;
@@ -323,8 +323,8 @@
 typedef ptr_alloc_ptr index_pointer;
 typedef const_iterator self_t;

- friend class deque<T, A>;
- friend class deque_base<T, A>;
+ friend class deque<T, Allocator>;
+ friend class deque_base<T, Allocator>;

 private:
 explicit iterator(const const_iterator& x) : const_iterator(x){}
@@ -525,15 +525,15 @@
//! Deque class
//!
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
-class deque : protected deque_base<T, A>
+class deque : protected deque_base<T, Allocator>
{
 /// @cond
 private:
- typedef deque_base<T, A> Base;
+ typedef deque_base<T, Allocator> Base;
 /// @endcond

 public:
@@ -544,19 +544,19 @@
 //
 //////////////////////////////////////////////

- typedef T value_type;
- typedef typename ::boost::container::allocator_traits<A>::pointer pointer;
- typedef typename ::boost::container::allocator_traits<A>::const_pointer const_pointer;
- typedef typename ::boost::container::allocator_traits<A>::reference reference;
- typedef typename ::boost::container::allocator_traits<A>::const_reference const_reference;
- typedef typename ::boost::container::allocator_traits<A>::size_type size_type;
- typedef typename ::boost::container::allocator_traits<A>::difference_type difference_type;
- typedef A allocator_type;
- typedef BOOST_CONTAINER_IMPDEF(allocator_type) stored_allocator_type;
- typedef BOOST_CONTAINER_IMPDEF(typename Base::iterator) iterator;
- typedef BOOST_CONTAINER_IMPDEF(typename Base::const_iterator) const_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;
+ typedef T value_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(allocator_type) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(typename Base::iterator) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(typename Base::const_iterator) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;

 /// @cond

@@ -568,7 +568,7 @@
 typedef container_detail::advanced_insert_aux_int<iterator> advanced_insert_aux_int_t;
 typedef repeat_iterator<T, difference_type> r_iterator;
 typedef boost::move_iterator<r_iterator> move_it;
- typedef allocator_traits<A> allocator_traits_type;
+ typedef allocator_traits<Allocator> allocator_traits_type;

 /// @endcond

@@ -607,7 +607,7 @@
 explicit deque(size_type n)
 : Base(n, allocator_type())
 {
- container_detail::default_construct_aux_proxy<A, iterator> proxy(this->alloc(), n);
+ container_detail::default_construct_aux_proxy<Allocator, iterator> proxy(this->alloc(), n);
 proxy.uninitialized_copy_remaining_to(this->begin());
 //deque_base will deallocate in case of exception...
 }
@@ -1020,7 +1020,7 @@
 this->priv_erase_last_n(len - new_size);
 else{
 const size_type n = new_size - this->size();
- container_detail::default_construct_aux_proxy<A, iterator> proxy(this->alloc(), n);
+ container_detail::default_construct_aux_proxy<Allocator, iterator> proxy(this->alloc(), n);
 priv_insert_back_aux_impl(n, proxy);
 }
 }
@@ -1176,7 +1176,7 @@
 this->priv_push_front_simple_commit();
 }
 else{
- typedef container_detail::advanced_insert_aux_non_movable_emplace<A, iterator, Args...> type;
+ typedef container_detail::advanced_insert_aux_non_movable_emplace<Allocator, iterator, Args...> type;
 type &&proxy = type(this->alloc(), boost::forward<Args>(args)...);
 this->priv_insert_front_aux_impl(1, proxy);
 }
@@ -1199,7 +1199,7 @@
 this->priv_push_back_simple_commit();
 }
 else{
- typedef container_detail::advanced_insert_aux_non_movable_emplace<A, iterator, Args...> type;
+ typedef container_detail::advanced_insert_aux_non_movable_emplace<Allocator, iterator, Args...> type;
 type &&proxy = type(this->alloc(), boost::forward<Args>(args)...);
 this->priv_insert_back_aux_impl(1, proxy);
 }
@@ -1226,7 +1226,7 @@
 return (this->end()-1);
 }
 else{
- typedef container_detail::advanced_insert_aux_emplace<A, iterator, Args...> type;
+ typedef container_detail::advanced_insert_aux_emplace<Allocator, iterator, Args...> type;
 type &&proxy = type(this->alloc(), boost::forward<Args>(args)...);
 return this->priv_insert_aux_impl(p, 1, proxy);
 }
@@ -1249,7 +1249,7 @@
 else{ \
 container_detail::BOOST_PP_CAT(BOOST_PP_CAT \
 (advanced_insert_aux_non_movable_emplace, n), arg) \
- <A, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
+ <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
 (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \
 priv_insert_front_aux_impl(1, proxy); \
 } \
@@ -1268,7 +1268,7 @@
 else{ \
 container_detail::BOOST_PP_CAT(BOOST_PP_CAT( \
 advanced_insert_aux_non_movable_emplace, n), arg) \
- <A, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
+ <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
 (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \
 priv_insert_back_aux_impl(1, proxy); \
 } \
@@ -1288,7 +1288,7 @@
 } \
 else{ \
 container_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
- <A, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
+ <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
 (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \
 return this->priv_insert_aux_impl(p, 1, proxy); \
 } \
@@ -1424,7 +1424,7 @@
 #endif
 )
 {
- container_detail::advanced_insert_aux_proxy<A, FwdIt, iterator> proxy(this->alloc(), first, last);
+ container_detail::advanced_insert_aux_proxy<Allocator, FwdIt, iterator> proxy(this->alloc(), first, last);
 return priv_insert_aux_impl(p, (size_type)std::distance(first, last), proxy);
 }
 #endif
@@ -1978,36 +1978,36 @@
};

// Nonmember functions.
-template <class T, class A>
-inline bool operator==(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
{
 return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
}

-template <class T, class A>
-inline bool operator<(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator<(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
{
 return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}

-template <class T, class A>
-inline bool operator!=(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator!=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
 { return !(x == y); }

-template <class T, class A>
-inline bool operator>(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
 { return y < x; }

-template <class T, class A>
-inline bool operator>=(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
 { return !(x < y); }

-template <class T, class A>
-inline bool operator<=(const deque<T, A>& x, const deque<T, A>& y)
+template <class T, class Allocator>
+inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y)
 { return !(y < x); }

-template <class T, class A>
-inline void swap(deque<T, A>& x, deque<T, A>& y)
+template <class T, class Allocator>
+inline void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
{ x.swap(y); }

}}
@@ -2018,10 +2018,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class A>
-struct has_trivial_destructor_after_move<boost::container::deque<T, A> >
+template <class T, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::deque<T, Allocator> >
{
- enum { value = has_trivial_destructor<A>::value };
+ enum { value = has_trivial_destructor<Allocator>::value };
};
*/
}

Modified: branches/release/boost/container/detail/flat_tree.hpp
==============================================================================
--- branches/release/boost/container/detail/flat_tree.hpp (original)
+++ branches/release/boost/container/detail/flat_tree.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -414,7 +414,8 @@
 void insert_equal(ordered_range_t, FwdIt first, FwdIt last
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 , typename container_detail::enable_if_c
- < container_detail::is_forward_iterator<FwdIt>::value
+ < !container_detail::is_input_iterator<FwdIt>::value &&
+ container_detail::is_forward_iterator<FwdIt>::value
>::type * = 0
 #endif
 )
@@ -491,9 +492,9 @@
 const const_iterator beg(this->cbegin());
 const_iterator pos(beg);
 const value_compare &value_comp = this->m_data;
+ skips[0u] = 0u;
 //Loop in burst sizes
 while(len){
- skips[0u] = 0u;
 const size_type burst = len < BurstSize ? len : BurstSize;
 size_type unique_burst = 0u;
 const const_iterator cend(this->cend());
@@ -503,20 +504,23 @@
 --len;
 pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend, KeyOfValue()(val));
 //Check if already present
- if(pos != cend && !value_comp(*pos, val)){
- ++skips[unique_burst];
+ if(pos != cend && !value_comp(val, *pos)){
+ if(unique_burst > 0){
+ ++skips[unique_burst-1];
+ }
 continue;
 }

 //If not present, calculate position
 positions[unique_burst] = static_cast<size_type>(pos - beg);
- if(++unique_burst < burst)
- skips[unique_burst] = 0u;
+ skips[unique_burst++] = 0u;
+ }
+ if(unique_burst){
+ //Insert all in a single step in the precalculated positions
+ this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
+ //Next search position updated
+ pos += unique_burst;
 }
- //Insert all in a single step in the precalculated positions
- this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
- //Next search position updated
- pos += unique_burst;
 }
 }

Modified: branches/release/boost/container/detail/tree.hpp
==============================================================================
--- branches/release/boost/container/detail/tree.hpp (original)
+++ branches/release/boost/container/detail/tree.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -41,7 +41,7 @@
namespace container_detail {

template<class Key, class Value, class KeyCompare, class KeyOfValue>
-struct value_compare_impl
+struct tree_value_compare
 : public KeyCompare
{
 typedef Value value_type;
@@ -49,7 +49,7 @@
 typedef KeyOfValue key_of_value;
 typedef Key key_type;

- value_compare_impl(const key_compare &kcomp)
+ tree_value_compare(const key_compare &kcomp)
 : key_compare(kcomp)
 {}

@@ -209,13 +209,13 @@
 : protected container_detail::node_alloc_holder
 < A
 , typename container_detail::intrusive_rbtree_type
- <A, value_compare_impl<Key, Value, KeyCompare, KeyOfValue>
+ <A, tree_value_compare<Key, Value, KeyCompare, KeyOfValue>
>::type
 , KeyCompare
>
{
 typedef typename container_detail::intrusive_rbtree_type
- < A, value_compare_impl
+ < A, tree_value_compare
 <Key, Value, KeyCompare, KeyOfValue>
>::type Icont;
 typedef container_detail::node_alloc_holder
@@ -315,7 +315,7 @@
 typedef Value value_type;
 typedef A allocator_type;
 typedef KeyCompare key_compare;
- typedef value_compare_impl< Key, Value
+ typedef tree_value_compare< Key, Value
 , KeyCompare, KeyOfValue> value_compare;
 typedef typename boost::container::
 allocator_traits<A>::pointer pointer;

Modified: branches/release/boost/container/detail/utilities.hpp
==============================================================================
--- branches/release/boost/container/detail/utilities.hpp (original)
+++ branches/release/boost/container/detail/utilities.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -122,36 +122,6 @@
{
enum { value = ((OrigSize-1)/RoundTo+1)*RoundTo };
};
-/*
-template <class _TypeT>
-struct __rw_is_enum
-{
- struct _C_no { };
- struct _C_yes { int _C_dummy [2]; };
-
- struct _C_indirect {
- // prevent classes with user-defined conversions from matching
-
- // use double to prevent float->int gcc conversion warnings
- _C_indirect (double);
-};
-
-// nested struct gets rid of bogus gcc errors
-struct _C_nest {
- // supply first argument to prevent HP aCC warnings
- static _C_no _C_is (int, ...);
- static _C_yes _C_is (int, _C_indirect);
-
- static _TypeT _C_make_T ();
-};
-
-enum {
- _C_val = sizeof (_C_yes) == sizeof (_C_nest::_C_is (0, _C_nest::_C_make_T ()))
- && !::boost::is_fundamental<_TypeT>::value
-};
-
-};
-*/

template<class T>
struct move_const_ref_type

Modified: branches/release/boost/container/flat_map.hpp
==============================================================================
--- branches/release/boost/container/flat_map.hpp (original)
+++ branches/release/boost/container/flat_map.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -28,27 +28,23 @@
#include <boost/container/detail/mpl.hpp>
#include <boost/container/allocator_traits.hpp>
#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>

-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace boost {
-namespace container {
-#else
namespace boost {
namespace container {
-#endif

/// @cond
// Forward declarations of operators == and <, needed for friend declarations.
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
class flat_map;

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y);
-
-template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y);
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y);
+
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y);

namespace container_detail{

@@ -78,9 +74,9 @@
//! flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
//! (unlike std::map<Key, T> which value_type is std::pair<const Key, T>).
//!
-//! Pred is the ordering function for Keys (e.g. std::less<Key>).
+//! Compare is the ordering function for Keys (e.g. std::less<Key>).
//!
-//! A is the allocator to allocate the value_types
+//! Allocator is the allocator to allocate the value_types
//! (e.g. allocator< std::pair<Key, T> >).
//!
//! flat_map is similar to std::map but it's implemented like an ordered vector.
@@ -90,9 +86,9 @@
//! Erasing an element of a flat_map invalidates iterators and references
//! pointing to elements that come after (their keys are bigger) the erased element.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Pred = std::less<Key>, class A = std::allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< Key, T> > >
#else
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
#endif
class flat_map
{
@@ -103,72 +99,68 @@
 typedef container_detail::flat_tree<Key,
 std::pair<Key, T>,
 container_detail::select1st< std::pair<Key, T> >,
- Pred,
- A> tree_t;
+ Compare,
+ Allocator> tree_t;

 //This is the real tree stored here. It's based on a movable pair
 typedef container_detail::flat_tree<Key,
 container_detail::pair<Key, T>,
 container_detail::select1st<container_detail::pair<Key, T> >,
- Pred,
- typename allocator_traits<A>::template portable_rebind_alloc
+ Compare,
+ typename allocator_traits<Allocator>::template portable_rebind_alloc
 <container_detail::pair<Key, T> >::type> impl_tree_t;
 impl_tree_t m_flat_tree; // flat tree representing flat_map

 typedef typename impl_tree_t::value_type impl_value_type;
- typedef typename impl_tree_t::pointer impl_pointer;
- typedef typename impl_tree_t::const_pointer impl_const_pointer;
- typedef typename impl_tree_t::reference impl_reference;
- typedef typename impl_tree_t::const_reference impl_const_reference;
- typedef typename impl_tree_t::value_compare impl_value_compare;
- typedef typename impl_tree_t::iterator impl_iterator;
 typedef typename impl_tree_t::const_iterator impl_const_iterator;
- typedef typename impl_tree_t::reverse_iterator impl_reverse_iterator;
- typedef typename impl_tree_t::const_reverse_iterator impl_const_reverse_iterator;
 typedef typename impl_tree_t::allocator_type impl_allocator_type;
- typedef allocator_traits<A> allocator_traits_type;
-
-
-
+ typedef container_detail::flat_tree_value_compare
+ < Compare
+ , container_detail::select1st< std::pair<Key, T> >
+ , std::pair<Key, T> > value_compare_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::iterator iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::const_iterator const_iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::reverse_iterator reverse_iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator const_reverse_iterator_impl;
 /// @endcond

 public:

- // typedefs:
- typedef Key key_type;
- typedef T mapped_type;
- typedef typename std::pair<key_type, mapped_type> value_type;
- typedef typename allocator_traits_type::pointer pointer;
- typedef typename allocator_traits_type::const_pointer const_pointer;
- typedef typename allocator_traits_type::reference reference;
- typedef typename allocator_traits_type::const_reference const_reference;
- typedef typename impl_tree_t::size_type size_type;
- typedef typename impl_tree_t::difference_type difference_type;
-
- typedef container_detail::flat_tree_value_compare
- < Pred
- , container_detail::select1st< std::pair<Key, T> >
- , std::pair<Key, T> > value_compare;
- typedef Pred key_compare;
- typedef typename container_detail::
- get_flat_tree_iterators<pointer>::iterator iterator;
- typedef typename container_detail::
- get_flat_tree_iterators<pointer>::const_iterator const_iterator;
- typedef typename container_detail::
- get_flat_tree_iterators
- <pointer>::reverse_iterator reverse_iterator;
- typedef typename container_detail::
- get_flat_tree_iterators
- <pointer>::const_reverse_iterator const_reverse_iterator;
- typedef A allocator_type;
-
- //!Standard extension
- typedef A stored_allocator_type;
-
- //!Standard extension for C++03 compilers with non-movable std::pair
- typedef impl_value_type movable_value_type;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef T mapped_type;
+ typedef std::pair<Key, T> value_type;
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(Allocator) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare;
+ typedef Compare key_compare;
+ typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl) const_reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(impl_value_type) movable_value_type;

 public:
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Default constructs an empty flat_map.
 //!
 //! Complexity: Constant.
@@ -179,7 +171,7 @@
 //! comparison object and allocator.
 //!
 //! Complexity: Constant.
- explicit flat_map(const Pred& comp, const allocator_type& a = allocator_type())
+ explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
 : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) {}

 //! Effects: Constructs an empty flat_map using the specified comparison object and
@@ -188,7 +180,7 @@
 //! Complexity: Linear in N if the range [first ,last ) is already sorted using
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
- flat_map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
+ flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(true, first, last, comp, container_detail::force<impl_allocator_type>(a))
 {}
@@ -205,7 +197,7 @@
 //! Note: Non-standard extension.
 template <class InputIterator>
 flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
- , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
+ , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
 : m_flat_tree(ordered_range, first, last, comp, a)
 {}

@@ -255,32 +247,38 @@
 flat_map& operator=(BOOST_RV_REF(flat_map) mx)
 { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+ allocator_type get_allocator() const
+ { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

- stored_allocator_type &get_stored_allocator()
- { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -384,6 +382,12 @@
 const_reverse_iterator crend() const
 { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -408,11 +412,47 @@
 size_type max_size() const
 { return m_flat_tree.max_size(); }

+ //! Effects: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ size_type capacity() const
+ { return m_flat_tree.capacity(); }
+
+ //! Effects: If n is less than or equal to capacity(), this call has no
+ //! effect. Otherwise, it is a request for allocation of additional memory.
+ //! If the request is successful, then capacity() is greater than or equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+ //!
+ //! Throws: If memory allocation allocation throws or T's copy constructor throws.
+ //!
+ //! Note: If capacity() is less than "count", iterators and references to
+ //! to values might be invalidated.
+ void reserve(size_type count)
+ { m_flat_tree.reserve(count); }
+
+ //! Effects: Tries to deallocate the excess of memory created
+ // with previous allocations. The size of the vector is unchanged
+ //!
+ //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //!
+ //! Complexity: Linear to size().
+ void shrink_to_fit()
+ { m_flat_tree.shrink_to_fit(); }
+
+ //////////////////////////////////////////////
+ //
+ // element access
+ //
+ //////////////////////////////////////////////
+
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: If there is no key equivalent to x in the flat_map, inserts
 //! value_type(x, T()) into the flat_map.
 //!
- //! Returns: A reference to the mapped_type corresponding to x in *this.
+ //! Returns: Allocator reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
 mapped_type &operator[](const key_type& k);
@@ -420,17 +460,19 @@
 //! Effects: If there is no key equivalent to x in the flat_map, inserts
 //! value_type(move(x), T()) into the flat_map (the key is move-constructed)
 //!
- //! Returns: A reference to the mapped_type corresponding to x in *this.
+ //! Returns: Allocator reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
 mapped_type &operator[](key_type &&k) ;

 #else
- BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, priv_subscript)
+ BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
 #endif

- //! Returns: A reference to the element whose key is equivalent to x.
+ //! Returns: Allocator reference to the element whose key is equivalent to x.
+ //!
 //! Throws: An exception object of type out_of_range if no such element is present.
+ //!
 //! Complexity: logarithmic.
 T& at(const key_type& k)
 {
@@ -441,8 +483,10 @@
 return i->second;
 }

- //! Returns: A reference to the element whose key is equivalent to x.
+ //! Returns: Allocator reference to the element whose key is equivalent to x.
+ //!
 //! Throws: An exception object of type out_of_range if no such element is present.
+ //!
 //! Complexity: logarithmic.
 const T& at(const key_type& k) const
 {
@@ -453,13 +497,69 @@
 return i->second;
 }

- //! Effects: Swaps the contents of *this and x.
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object x of type T constructed with
+ //! std::forward<Args>(args)... if and only if there is no element in the container
+ //! with key equivalent to the key of x.
 //!
- //! Throws: Nothing.
+ //! Returns: The bool component of the returned pair is true if and only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
 //!
- //! Complexity: Constant.
- void swap(flat_map& x)
- { m_flat_tree.swap(x.m_flat_tree); }
+ //! Complexity: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ std::pair<iterator,bool> emplace(Args&&... args)
+ { return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
+
+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the container if and only if there is
+ //! no element in the container with key equivalent to the key of x.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return container_detail::force_copy<iterator>
+ (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
+ , boost::forward<Args>(args)...));
+ }
+
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return container_detail::force_copy< std::pair<iterator, bool> > \
+ (m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique \
+ (container_detail::force_copy<impl_const_iterator>(hint) \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

 //! Effects: Inserts x if and only if there is no element in the container
 //! with key equivalent to the key of x.
@@ -587,64 +687,6 @@
 void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
 { m_flat_tree.insert_unique(ordered_unique_range, first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object x of type T constructed with
- //! std::forward<Args>(args)... if and only if there is no element in the container
- //! with key equivalent to the key of x.
- //!
- //! Returns: The bool component of the returned pair is true if and only
- //! if the insertion takes place, and the iterator component of the pair
- //! points to the element with key equivalent to the key of x.
- //!
- //! Complexity: Logarithmic search time plus linear insertion
- //! to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- std::pair<iterator,bool> emplace(Args&&... args)
- { return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container if and only if there is
- //! no element in the container with key equivalent to the key of x.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic search time (constant if x is inserted
- //! right before p) plus insertion linear to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- {
- return container_detail::force_copy<iterator>
- (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
- , boost::forward<Args>(args)...));
- }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return container_detail::force_copy< std::pair<iterator, bool> > \
- (m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique \
- (container_detail::force_copy<impl_const_iterator>(hint) \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by position.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -685,6 +727,14 @@
 , container_detail::force_copy<impl_const_iterator>(last)));
 }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(flat_map& x)
+ { m_flat_tree.swap(x.m_flat_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -693,14 +743,31 @@
 void clear()
 { m_flat_tree.clear(); }

- //! Effects: Tries to deallocate the excess of memory created
- // with previous allocations. The size of the vector is unchanged
+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
 //!
- //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
 //!
- //! Complexity: Linear to size().
- void shrink_to_fit()
- { m_flat_tree.shrink_to_fit(); }
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+
+ //////////////////////////////////////////////
+ //
+ // map operations
+ //
+ //////////////////////////////////////////////

 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
@@ -709,7 +776,7 @@
 iterator find(const key_type& x)
 { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }

- //! Returns: A const_iterator pointing to an element with the key
+ //! Returns: Allocator const_iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.s
@@ -729,7 +796,7 @@
 iterator lower_bound(const key_type& x)
 { return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -743,7 +810,7 @@
 iterator upper_bound(const key_type& x)
 { return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -762,27 +829,6 @@
 std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
 { return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x)); }

- //! Effects: Number of elements for which memory has been allocated.
- //! capacity() is always greater than or equal to size().
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- size_type capacity() const
- { return m_flat_tree.capacity(); }
-
- //! Effects: If n is less than or equal to capacity(), this call has no
- //! effect. Otherwise, it is a request for allocation of additional memory.
- //! If the request is successful, then capacity() is greater than or equal to
- //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
- //!
- //! Throws: If memory allocation allocation throws or T's copy constructor throws.
- //!
- //! Note: If capacity() is less than "count", iterators and references to
- //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
-
 /// @cond
 template <class K1, class T1, class C1, class A1>
 friend bool operator== (const flat_map<K1, T1, C1, A1>&,
@@ -816,39 +862,39 @@
 /// @endcond
};

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return x.m_flat_tree == y.m_flat_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return x.m_flat_tree < y.m_flat_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator!=(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator!=(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return !(x == y); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return y < x; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<=(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<=(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return !(y < x); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>=(const flat_map<Key,T,Pred,A>& x,
- const flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>=(const flat_map<Key,T,Compare,Allocator>& x,
+ const flat_map<Key,T,Compare,Allocator>& y)
 { return !(x < y); }

-template <class Key, class T, class Pred, class A>
-inline void swap(flat_map<Key,T,Pred,A>& x,
- flat_map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline void swap(flat_map<Key,T,Compare,Allocator>& x,
+ flat_map<Key,T,Compare,Allocator>& y)
 { x.swap(y); }

/// @cond
@@ -857,25 +903,25 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class K, class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::flat_map<K, T, C, A> >
+template <class K, class T, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::flat_map<K, T, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

// Forward declaration of operators < and ==, needed for friend declaration.
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
class flat_multimap;

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y);
-
-template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y);
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y);
+
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y);
/// @endcond

//! A flat_multimap is a kind of associative container that supports equivalent keys
@@ -888,14 +934,14 @@
//! flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
//! (unlike std::multimap<Key, T> which value_type is std::pair<const Key, T>).
//!
-//! Pred is the ordering function for Keys (e.g. std::less<Key>).
+//! Compare is the ordering function for Keys (e.g. std::less<Key>).
//!
-//! A is the allocator to allocate the value_types
+//! Allocator is the allocator to allocate the value_types
//! (e.g. allocator< std::pair<Key, T> >).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Pred = std::less<Key>, class A = std::allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< Key, T> > >
#else
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
#endif
class flat_multimap
{
@@ -905,65 +951,65 @@
 typedef container_detail::flat_tree<Key,
 std::pair<Key, T>,
 container_detail::select1st< std::pair<Key, T> >,
- Pred,
- A> tree_t;
+ Compare,
+ Allocator> tree_t;
 //This is the real tree stored here. It's based on a movable pair
 typedef container_detail::flat_tree<Key,
 container_detail::pair<Key, T>,
 container_detail::select1st<container_detail::pair<Key, T> >,
- Pred,
- typename allocator_traits<A>::template portable_rebind_alloc
+ Compare,
+ typename allocator_traits<Allocator>::template portable_rebind_alloc
 <container_detail::pair<Key, T> >::type> impl_tree_t;
 impl_tree_t m_flat_tree; // flat tree representing flat_map

 typedef typename impl_tree_t::value_type impl_value_type;
- typedef typename impl_tree_t::pointer impl_pointer;
- typedef typename impl_tree_t::const_pointer impl_const_pointer;
- typedef typename impl_tree_t::reference impl_reference;
- typedef typename impl_tree_t::const_reference impl_const_reference;
- typedef typename impl_tree_t::value_compare impl_value_compare;
- typedef typename impl_tree_t::iterator impl_iterator;
 typedef typename impl_tree_t::const_iterator impl_const_iterator;
- typedef typename impl_tree_t::reverse_iterator impl_reverse_iterator;
- typedef typename impl_tree_t::const_reverse_iterator impl_const_reverse_iterator;
 typedef typename impl_tree_t::allocator_type impl_allocator_type;
- typedef allocator_traits<A> allocator_traits_type;
-
+ typedef container_detail::flat_tree_value_compare
+ < Compare
+ , container_detail::select1st< std::pair<Key, T> >
+ , std::pair<Key, T> > value_compare_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::iterator iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::const_iterator const_iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::reverse_iterator reverse_iterator_impl;
+ typedef typename container_detail::get_flat_tree_iterators
+ <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator const_reverse_iterator_impl;
 /// @endcond

 public:

- // typedefs:
- typedef Key key_type;
- typedef T mapped_type;
- typedef Pred key_compare;
- typedef typename std::pair<key_type, mapped_type> value_type;
- typedef typename allocator_traits_type::pointer pointer;
- typedef typename allocator_traits_type::const_pointer const_pointer;
- typedef typename allocator_traits_type::reference reference;
- typedef typename allocator_traits_type::const_reference const_reference;
- typedef typename impl_tree_t::size_type size_type;
- typedef typename impl_tree_t::difference_type difference_type;
- typedef container_detail::flat_tree_value_compare
- < Pred
- , container_detail::select1st< std::pair<Key, T> >
- , std::pair<Key, T> > value_compare;
-
- typedef typename container_detail::
- get_flat_tree_iterators<pointer>::iterator iterator;
- typedef typename container_detail::
- get_flat_tree_iterators<pointer>::const_iterator const_iterator;
- typedef typename container_detail::
- get_flat_tree_iterators
- <pointer>::reverse_iterator reverse_iterator;
- typedef typename container_detail::
- get_flat_tree_iterators
- <pointer>::const_reverse_iterator const_reverse_iterator;
- typedef A allocator_type;
- //Non-standard extension
- typedef A stored_allocator_type;
- //!Standard extension for C++03 compilers with non-movable std::pair
- typedef impl_value_type movable_value_type;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef T mapped_type;
+ typedef std::pair<Key, T> value_type;
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(Allocator) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare;
+ typedef Compare key_compare;
+ typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl) const_reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(impl_value_type) movable_value_type;
+
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Default constructs an empty flat_map.
 //!
@@ -975,7 +1021,7 @@
 //! object and allocator.
 //!
 //! Complexity: Constant.
- explicit flat_multimap(const Pred& comp,
+ explicit flat_multimap(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) { }

@@ -986,7 +1032,7 @@
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
 flat_multimap(InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(false, first, last, comp, container_detail::force<impl_allocator_type>(a))
 {}
@@ -1002,7 +1048,7 @@
 //! Note: Non-standard extension.
 template <class InputIterator>
 flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(ordered_range, first, last, comp, a)
 {}
@@ -1020,7 +1066,7 @@
 //! Postcondition: x is emptied.
 flat_multimap(BOOST_RV_REF(flat_multimap) x)
 : m_flat_tree(boost::move(x.m_flat_tree))
- { }
+ {}

 //! Effects: Copy constructs a flat_multimap using the specified allocator.
 //!
@@ -1049,32 +1095,38 @@
 flat_multimap& operator=(BOOST_RV_REF(flat_multimap) mx)
 { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+ allocator_type get_allocator() const
+ { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }

- stored_allocator_type &get_stored_allocator()
- { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -1178,6 +1230,12 @@
 const_reverse_iterator crend() const
 { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -1202,13 +1260,94 @@
 size_type max_size() const
 { return m_flat_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
+ //! Effects: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- void swap(flat_multimap& x)
- { m_flat_tree.swap(x.m_flat_tree); }
+ size_type capacity() const
+ { return m_flat_tree.capacity(); }
+
+ //! Effects: If n is less than or equal to capacity(), this call has no
+ //! effect. Otherwise, it is a request for allocation of additional memory.
+ //! If the request is successful, then capacity() is greater than or equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+ //!
+ //! Throws: If memory allocation allocation throws or T's copy constructor throws.
+ //!
+ //! Note: If capacity() is less than "count", iterators and references to
+ //! to values might be invalidated.
+ void reserve(size_type count)
+ { m_flat_tree.reserve(count); }
+
+ //! Effects: Tries to deallocate the excess of memory created
+ // with previous allocations. The size of the vector is unchanged
+ //!
+ //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //!
+ //! Complexity: Linear to size().
+ void shrink_to_fit()
+ { m_flat_tree.shrink_to_fit(); }
+
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... and returns the iterator pointing to the
+ //! newly inserted element.
+ //!
+ //! Complexity: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ { return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
+
+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic search time (constant time if the value
+ //! is to be inserted before p) plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
+ (container_detail::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
+ }
+
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal \
+ (BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal \
+ (container_detail::force_copy<impl_const_iterator>(hint) \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

 //! Effects: Inserts x and returns the iterator pointing to the
 //! newly inserted element.
@@ -1324,59 +1463,6 @@
 void insert(ordered_range_t, InputIterator first, InputIterator last)
 { m_flat_tree.insert_equal(ordered_range, first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... and returns the iterator pointing to the
- //! newly inserted element.
- //!
- //! Complexity: Logarithmic search time plus linear insertion
- //! to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace(Args&&... args)
- { return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic search time (constant time if the value
- //! is to be inserted before p) plus linear insertion
- //! to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- {
- return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
- (container_detail::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
- }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal \
- (BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal \
- (container_detail::force_copy<impl_const_iterator>(hint) \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))); } \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by position.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -1417,6 +1503,14 @@
 , container_detail::force_copy<impl_const_iterator>(last)));
 }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(flat_multimap& x)
+ { m_flat_tree.swap(x.m_flat_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -1425,14 +1519,31 @@
 void clear()
 { m_flat_tree.clear(); }

- //! Effects: Tries to deallocate the excess of memory created
- // with previous allocations. The size of the vector is unchanged
+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
 //!
- //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
 //!
- //! Complexity: Linear to size().
- void shrink_to_fit()
- { m_flat_tree.shrink_to_fit(); }
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+
+ //////////////////////////////////////////////
+ //
+ // map operations
+ //
+ //////////////////////////////////////////////

 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
@@ -1459,9 +1570,9 @@
 //!
 //! Complexity: Logarithmic
 iterator lower_bound(const key_type& x)
- {return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
+ { return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }

- //! Returns: A const iterator pointing to the first element with key
+ //! Returns: Allocator const iterator pointing to the first element with key
 //! not less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1475,7 +1586,7 @@
 iterator upper_bound(const key_type& x)
 {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }

- //! Returns: A const iterator pointing to the first element with key
+ //! Returns: Allocator const iterator pointing to the first element with key
 //! not less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1491,31 +1602,9 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator,const_iterator>
- equal_range(const key_type& x) const
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
 { return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x)); }

- //! Effects: Number of elements for which memory has been allocated.
- //! capacity() is always greater than or equal to size().
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- size_type capacity() const
- { return m_flat_tree.capacity(); }
-
- //! Effects: If n is less than or equal to capacity(), this call has no
- //! effect. Otherwise, it is a request for allocation of additional memory.
- //! If the request is successful, then capacity() is greater than or equal to
- //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
- //!
- //! Throws: If memory allocation allocation throws or T's copy constructor throws.
- //!
- //! Note: If capacity() is less than "count", iterators and references to
- //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
-
 /// @cond
 template <class K1, class T1, class C1, class A1>
 friend bool operator== (const flat_multimap<K1, T1, C1, A1>& x,
@@ -1527,38 +1616,38 @@
 /// @endcond
};

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return x.m_flat_tree == y.m_flat_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return x.m_flat_tree < y.m_flat_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator!=(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator!=(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return !(x == y); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return y < x; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<=(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<=(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return !(y < x); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>=(const flat_multimap<Key,T,Pred,A>& x,
- const flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>=(const flat_multimap<Key,T,Compare,Allocator>& x,
+ const flat_multimap<Key,T,Compare,Allocator>& y)
 { return !(x < y); }

-template <class Key, class T, class Pred, class A>
-inline void swap(flat_multimap<Key,T,Pred,A>& x, flat_multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline void swap(flat_multimap<Key,T,Compare,Allocator>& x, flat_multimap<Key,T,Compare,Allocator>& y)
 { x.swap(y); }

}}
@@ -1569,10 +1658,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class K, class T, class C, class A>
-struct has_trivial_destructor_after_move< boost::container::flat_multimap<K, T, C, A> >
+template <class K, class T, class C, class Allocator>
+struct has_trivial_destructor_after_move< boost::container::flat_multimap<K, T, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
} //namespace boost {

Modified: branches/release/boost/container/flat_set.hpp
==============================================================================
--- branches/release/boost/container/flat_set.hpp (original)
+++ branches/release/boost/container/flat_set.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -24,33 +24,30 @@
#include <memory>
#include <boost/container/detail/flat_tree.hpp>
#include <boost/container/detail/mpl.hpp>
+#include <boost/container/allocator_traits.hpp>
#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>

-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace boost {
-namespace container {
-#else
namespace boost {
namespace container {
-#endif

/// @cond
// Forward declarations of operators < and ==, needed for friend declaration.

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class flat_set;

-template <class T, class Pred, class A>
-inline bool operator==(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y);
-
-template <class T, class Pred, class A>
-inline bool operator<(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y);
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y);
+
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y);
/// @endcond

//! flat_set is a Sorted Associative Container that stores objects of type Key.
@@ -65,40 +62,48 @@
//! Erasing an element of a flat_set invalidates iterators and references
//! pointing to elements that come after (their keys are bigger) the erased element.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class flat_set
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(flat_set)
- typedef container_detail::flat_tree<T, T, container_detail::identity<T>, Pred, A> tree_t;
+ typedef container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> tree_t;
 tree_t m_flat_tree; // flat tree representing flat_set
- typedef typename container_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 /// @endcond

 public:
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef Key value_type;
+ typedef Compare key_compare;
+ typedef Compare value_compare;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;

- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef typename tree_t::key_compare key_compare;
- typedef typename tree_t::value_compare value_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
+ public:
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Default constructs an empty flat_set.
 //!
@@ -111,7 +116,7 @@
 //! comparison object and allocator.
 //!
 //! Complexity: Constant.
- explicit flat_set(const Pred& comp,
+ explicit flat_set(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_flat_tree(comp, a)
 {}
@@ -123,7 +128,7 @@
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
 flat_set(InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(true, first, last, comp, a)
 {}
@@ -140,7 +145,7 @@
 //! Note: Non-standard extension.
 template <class InputIterator>
 flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(ordered_range, first, last, comp, a)
 {}
@@ -188,32 +193,38 @@
 flat_set& operator=(BOOST_RV_REF(flat_set) mx)
 { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return m_flat_tree.key_comp(); }
+ allocator_type get_allocator() const
+ { return m_flat_tree.get_allocator(); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return m_flat_tree.key_comp(); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return m_flat_tree.get_stored_allocator(); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return m_flat_tree.get_allocator(); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return m_flat_tree.get_stored_allocator(); }

- stored_allocator_type &get_stored_allocator()
- { return m_flat_tree.get_stored_allocator(); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -231,14 +242,6 @@
 const_iterator begin() const
 { return m_flat_tree.begin(); }

- //! Effects: Returns a const_iterator to the first element contained in the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cbegin() const
- { return m_flat_tree.cbegin(); }
-
 //! Effects: Returns an iterator to the end of the container.
 //!
 //! Throws: Nothing.
@@ -255,14 +258,6 @@
 const_iterator end() const
 { return m_flat_tree.end(); }

- //! Effects: Returns a const_iterator to the end of the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cend() const
- { return m_flat_tree.cend(); }
-
 //! Effects: Returns a reverse_iterator pointing to the beginning
 //! of the reversed container.
 //!
@@ -281,32 +276,48 @@
 const_reverse_iterator rbegin() const
 { return m_flat_tree.rbegin(); }

- //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed container.
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- const_reverse_iterator crbegin() const
- { return m_flat_tree.crbegin(); }
+ reverse_iterator rend()
+ { return m_flat_tree.rend(); }

- //! Effects: Returns a reverse_iterator pointing to the end
+ //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed container.
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- reverse_iterator rend()
+ const_reverse_iterator rend() const
 { return m_flat_tree.rend(); }

- //! Effects: Returns a const_reverse_iterator pointing to the end
+ //! Effects: Returns a const_iterator to the first element contained in the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cbegin() const
+ { return m_flat_tree.cbegin(); }
+
+ //! Effects: Returns a const_iterator to the end of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cend() const
+ { return m_flat_tree.cend(); }
+
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed container.
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- const_reverse_iterator rend() const
- { return m_flat_tree.rend(); }
+ const_reverse_iterator crbegin() const
+ { return m_flat_tree.crbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed container.
@@ -317,6 +328,13 @@
 const_reverse_iterator crend() const
 { return m_flat_tree.crend(); }

+
+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -341,15 +359,46 @@
 size_type max_size() const
 { return m_flat_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
+ //! Effects: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- void swap(flat_set& x)
- { m_flat_tree.swap(x.m_flat_tree); }
+ size_type capacity() const
+ { return m_flat_tree.capacity(); }

- //! Effects: Inserts x if and only if there is no element in the container
+ //! Effects: If n is less than or equal to capacity(), this call has no
+ //! effect. Otherwise, it is a request for allocation of additional memory.
+ //! If the request is successful, then capacity() is greater than or equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+ //!
+ //! Throws: If memory allocation allocation throws or Key's copy constructor throws.
+ //!
+ //! Note: If capacity() is less than "count", iterators and references to
+ //! to values might be invalidated.
+ void reserve(size_type count)
+ { m_flat_tree.reserve(count); }
+
+ //! Effects: Tries to deallocate the excess of memory created
+ // with previous allocations. The size of the vector is unchanged
+ //!
+ //! Throws: If memory allocation throws, or Key's copy constructor throws.
+ //!
+ //! Complexity: Linear to size().
+ void shrink_to_fit()
+ { m_flat_tree.shrink_to_fit(); }
+
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object x of type Key constructed with
+ //! std::forward<Args>(args)... if and only if there is no element in the container
 //! with key equivalent to the key of x.
 //!
 //! Returns: The bool component of the returned pair is true if and only
@@ -360,17 +409,57 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- std::pair<iterator, bool> insert(insert_const_ref_type x)
- { return priv_insert(x); }
+ template <class... Args>
+ std::pair<iterator,bool> emplace(Args&&... args)
+ { return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }
+
+ //! Effects: Inserts an object of type Key constructed with
+ //! std::forward<Args>(args)... in the container if and only if there is
+ //! no element in the container with key equivalent to the key of x.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ { return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }

- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- std::pair<iterator, bool> insert(T &x)
- { return this->insert(const_cast<const T &>(x)); }
-
- template<class U>
- std::pair<iterator, bool> insert(const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(u); }
- #endif
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_flat_tree.emplace_hint_unique \
+ (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+ //! Effects: Inserts x if and only if there is no element in the container
+ //! with key equivalent to the key of x.
+ //!
+ //! Returns: The bool component of the returned pair is true if and only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
+ //!
+ //! Complexity: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ std::pair<iterator, bool> insert(const value_type &x);

 //! Effects: Inserts a new value_type move constructed from the pair if and
 //! only if there is no element in the container with key equivalent to the key of x.
@@ -383,9 +472,15 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(boost::move(x)); }
+ std::pair<iterator, bool> insert(value_type &&x);
+ #else
+ private:
+ typedef std::pair<iterator, bool> insert_return_pair;
+ public:
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->priv_insert)
+ #endif

+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: Inserts a copy of x in the container if and only if there is
 //! no element in the container with key equivalent to the key of x.
 //! p is a hint pointing to where the insert should start to search.
@@ -397,17 +492,7 @@
 //! right before p) plus insertion linear to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(const_iterator p, insert_const_ref_type x)
- { return priv_insert(p, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const_iterator position, const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(position, u); }
- #endif
+ iterator insert(const_iterator p, const value_type &x);

 //! Effects: Inserts an element move constructed from x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -418,8 +503,10 @@
 //! right before p) plus insertion linear to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(position, boost::move(x)); }
+ iterator insert(const_iterator position, value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
+ #endif

 //! Requires: first, last are not iterators into *this.
 //!
@@ -449,58 +536,6 @@
 void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
 { m_flat_tree.insert_unique(ordered_unique_range, first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object x of type T constructed with
- //! std::forward<Args>(args)... if and only if there is no element in the container
- //! with key equivalent to the key of x.
- //!
- //! Returns: The bool component of the returned pair is true if and only
- //! if the insertion takes place, and the iterator component of the pair
- //! points to the element with key equivalent to the key of x.
- //!
- //! Complexity: Logarithmic search time plus linear insertion
- //! to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- std::pair<iterator,bool> emplace(Args&&... args)
- { return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container if and only if there is
- //! no element in the container with key equivalent to the key of x.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic search time (constant if x is inserted
- //! right before p) plus insertion linear to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_flat_tree.emplace_hint_unique \
- (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by position.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -534,6 +569,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_flat_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(flat_set& x)
+ { m_flat_tree.swap(x.m_flat_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -542,14 +585,31 @@
 void clear()
 { m_flat_tree.clear(); }

- //! Effects: Tries to deallocate the excess of memory created
- // with previous allocations. The size of the vector is unchanged
+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
 //!
- //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_flat_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
 //!
- //! Complexity: Linear to size().
- void shrink_to_fit()
- { m_flat_tree.shrink_to_fit(); }
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return m_flat_tree.key_comp(); }
+
+ //////////////////////////////////////////////
+ //
+ // set operations
+ //
+ //////////////////////////////////////////////

 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
@@ -558,7 +618,7 @@
 iterator find(const key_type& x)
 { return m_flat_tree.find(x); }

- //! Returns: A const_iterator pointing to an element with the key
+ //! Returns: Allocator const_iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.s
@@ -578,7 +638,7 @@
 iterator lower_bound(const key_type& x)
 { return m_flat_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -592,7 +652,7 @@
 iterator upper_bound(const key_type& x)
 { return m_flat_tree.upper_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -602,38 +662,15 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator, const_iterator>
- equal_range(const key_type& x) const
+ std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
 { return m_flat_tree.equal_range(x); }

 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<iterator,iterator>
- equal_range(const key_type& x)
+ std::pair<iterator,iterator> equal_range(const key_type& x)
 { return m_flat_tree.equal_range(x); }

- //! Effects: Number of elements for which memory has been allocated.
- //! capacity() is always greater than or equal to size().
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- size_type capacity() const
- { return m_flat_tree.capacity(); }
-
- //! Effects: If n is less than or equal to capacity(), this call has no
- //! effect. Otherwise, it is a request for allocation of additional memory.
- //! If the request is successful, then capacity() is greater than or equal to
- //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
- //!
- //! Throws: If memory allocation allocation throws or T's copy constructor throws.
- //!
- //! Note: If capacity() is less than "count", iterators and references to
- //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
-
 /// @cond
 template <class K1, class C1, class A1>
 friend bool operator== (const flat_set<K1,C1,A1>&, const flat_set<K1,C1,A1>&);
@@ -642,46 +679,48 @@
 friend bool operator< (const flat_set<K1,C1,A1>&, const flat_set<K1,C1,A1>&);

 private:
- std::pair<iterator, bool> priv_insert(const T &x)
- { return m_flat_tree.insert_unique(x); }
-
- iterator priv_insert(const_iterator p, const T &x)
- { return m_flat_tree.insert_unique(p, x); }
+ template<class KeyType>
+ std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+ { return m_flat_tree.insert_unique(::boost::forward<KeyType>(x)); }
+
+ template<class KeyType>
+ iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+ { return m_flat_tree.insert_unique(p, ::boost::forward<KeyType>(x)); }
 /// @endcond
};

-template <class T, class Pred, class A>
-inline bool operator==(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return x.m_flat_tree == y.m_flat_tree; }

-template <class T, class Pred, class A>
-inline bool operator<(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return x.m_flat_tree < y.m_flat_tree; }

-template <class T, class Pred, class A>
-inline bool operator!=(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator!=(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return !(x == y); }

-template <class T, class Pred, class A>
-inline bool operator>(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return y < x; }

-template <class T, class Pred, class A>
-inline bool operator<=(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<=(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return !(y < x); }

-template <class T, class Pred, class A>
-inline bool operator>=(const flat_set<T,Pred,A>& x,
- const flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>=(const flat_set<Key,Compare,Allocator>& x,
+ const flat_set<Key,Compare,Allocator>& y)
 { return !(x < y); }

-template <class T, class Pred, class A>
-inline void swap(flat_set<T,Pred,A>& x, flat_set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline void swap(flat_set<Key,Compare,Allocator>& x, flat_set<Key,Compare,Allocator>& y)
 { x.swap(y); }

/// @cond
@@ -690,10 +729,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::flat_set<T, C, A> >
+template <class Key, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::flat_set<Key, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value &&has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value &&has_trivial_destructor<C>::value;
};
*/
namespace container {
@@ -701,19 +740,19 @@
// Forward declaration of operators < and ==, needed for friend declaration.

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class flat_multiset;

-template <class T, class Pred, class A>
-inline bool operator==(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y);
-
-template <class T, class Pred, class A>
-inline bool operator<(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y);
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y);
+
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y);
/// @endcond

//! flat_multiset is a Sorted Associative Container that stores objects of type Key.
@@ -728,39 +767,41 @@
//! 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.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class flat_multiset
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
- typedef container_detail::flat_tree<T, T, container_detail::identity<T>, Pred, A> tree_t;
+ typedef container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> tree_t;
 tree_t m_flat_tree; // flat tree representing flat_multiset
- typedef typename container_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 /// @endcond

 public:
- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef typename tree_t::key_compare key_compare;
- typedef typename tree_t::value_compare value_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef Key value_type;
+ typedef Compare key_compare;
+ typedef Compare value_compare;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;

 //! Effects: Default constructs an empty flat_multiset.
 //!
@@ -769,13 +810,13 @@
 : m_flat_tree()
 {}

- explicit flat_multiset(const Pred& comp,
+ explicit flat_multiset(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_flat_tree(comp, a) {}

 template <class InputIterator>
 flat_multiset(InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(false, first, last, comp, a)
 {}
@@ -791,7 +832,7 @@
 //! Note: Non-standard extension.
 template <class InputIterator>
 flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_flat_tree(ordered_range, first, last, comp, a)
 {}
@@ -839,20 +880,6 @@
 flat_multiset& operator=(BOOST_RV_REF(flat_multiset) mx)
 { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
- //!
- //! Complexity: Constant.
- key_compare key_comp() const
- { return m_flat_tree.key_comp(); }
-
- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
- //!
- //! Complexity: Constant.
- value_compare value_comp() const
- { return m_flat_tree.key_comp(); }
-
 //! Effects: Returns a copy of the Allocator that
 //! was passed to the object's constructor.
 //!
@@ -860,10 +887,24 @@
 allocator_type get_allocator() const
 { return m_flat_tree.get_allocator(); }

- const stored_allocator_type &get_stored_allocator() const
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
+ //!
+ //! Complexity: Constant.
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
 { return m_flat_tree.get_stored_allocator(); }

- stored_allocator_type &get_stored_allocator()
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
+ //!
+ //! Complexity: Constant.
+ //!
+ //! Note: Non-standard extension.
+ const stored_allocator_type &get_stored_allocator() const
 { return m_flat_tree.get_stored_allocator(); }

 //! Effects: Returns an iterator to the first element contained in the container.
@@ -968,6 +1009,12 @@
 const_reverse_iterator crend() const
 { return m_flat_tree.crend(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -992,32 +1039,98 @@
 size_type max_size() const
 { return m_flat_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
+ //! Effects: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
 //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- void swap(flat_multiset& x)
- { m_flat_tree.swap(x.m_flat_tree); }
+ size_type capacity() const
+ { return m_flat_tree.capacity(); }

- //! Effects: Inserts x and returns the iterator pointing to the
+ //! Effects: If n is less than or equal to capacity(), this call has no
+ //! effect. Otherwise, it is a request for allocation of additional memory.
+ //! If the request is successful, then capacity() is greater than or equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+ //!
+ //! Throws: If memory allocation allocation throws or Key's copy constructor throws.
+ //!
+ //! Note: If capacity() is less than "count", iterators and references to
+ //! to values might be invalidated.
+ void reserve(size_type count)
+ { m_flat_tree.reserve(count); }
+
+ //! Effects: Tries to deallocate the excess of memory created
+ // with previous allocations. The size of the vector is unchanged
+ //!
+ //! Throws: If memory allocation throws, or Key's copy constructor throws.
+ //!
+ //! Complexity: Linear to size().
+ void shrink_to_fit()
+ { m_flat_tree.shrink_to_fit(); }
+
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object of type Key constructed with
+ //! std::forward<Args>(args)... and returns the iterator pointing to the
 //! newly inserted element.
 //!
 //! Complexity: Logarithmic search time plus linear insertion
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(insert_const_ref_type x)
- { return priv_insert(x); }
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ { return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); }

- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(T &x)
- { return this->insert(const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(u); }
- #endif
+ //! Effects: Inserts an object of type Key constructed with
+ //! std::forward<Args>(args)... in the container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ { return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
+
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_flat_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_flat_tree.emplace_hint_equal \
+ (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+ //! Effects: Inserts x and returns the iterator pointing to the
+ //! newly inserted element.
+ //!
+ //! Complexity: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! Note: If an element is inserted it might invalidate elements.
+ iterator insert(const value_type &x);

 //! Effects: Inserts a new value_type move constructed from x
 //! and returns the iterator pointing to the newly inserted element.
@@ -1026,9 +1139,12 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(BOOST_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(boost::move(x)); }
+ iterator insert(value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, iterator, this->priv_insert)
+ #endif

+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
 //!
@@ -1039,18 +1155,7 @@
 //! right before p) plus insertion linear to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(const_iterator p, insert_const_ref_type x)
- { return priv_insert(p, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert( const_iterator position, const U &u
- , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(position, u); }
- #endif
+ iterator insert(const_iterator p, const value_type &x);

 //! Effects: Inserts a new value move constructed from x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -1062,8 +1167,10 @@
 //! right before p) plus insertion linear to the elements with bigger keys than x.
 //!
 //! Note: If an element is inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(position, boost::move(x)); }
+ iterator insert(const_iterator position, value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
+ #endif

 //! Requires: first, last are not iterators into *this.
 //!
@@ -1091,53 +1198,6 @@
 void insert(ordered_range_t, InputIterator first, InputIterator last)
 { m_flat_tree.insert_equal(ordered_range, first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... and returns the iterator pointing to the
- //! newly inserted element.
- //!
- //! Complexity: Logarithmic search time plus linear insertion
- //! to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace(Args&&... args)
- { return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic search time (constant if x is inserted
- //! right before p) plus insertion linear to the elements with bigger keys than x.
- //!
- //! Note: If an element is inserted it might invalidate elements.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_flat_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_flat_tree.emplace_hint_equal \
- (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by position.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -1171,6 +1231,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_flat_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(flat_multiset& x)
+ { m_flat_tree.swap(x.m_flat_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -1179,14 +1247,31 @@
 void clear()
 { m_flat_tree.clear(); }

- //! Effects: Tries to deallocate the excess of memory created
- // with previous allocations. The size of the vector is unchanged
+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
 //!
- //! Throws: If memory allocation throws, or T's copy constructor throws.
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_flat_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
 //!
- //! Complexity: Linear to size().
- void shrink_to_fit()
- { m_flat_tree.shrink_to_fit(); }
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return m_flat_tree.key_comp(); }
+
+ //////////////////////////////////////////////
+ //
+ // set operations
+ //
+ //////////////////////////////////////////////

 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
@@ -1195,7 +1280,7 @@
 iterator find(const key_type& x)
 { return m_flat_tree.find(x); }

- //! Returns: A const_iterator pointing to an element with the key
+ //! Returns: Allocator const_iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.s
@@ -1215,7 +1300,7 @@
 iterator lower_bound(const key_type& x)
 { return m_flat_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1229,7 +1314,7 @@
 iterator upper_bound(const key_type& x)
 { return m_flat_tree.upper_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1239,38 +1324,15 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator, const_iterator>
- equal_range(const key_type& x) const
+ std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
 { return m_flat_tree.equal_range(x); }

 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<iterator,iterator>
- equal_range(const key_type& x)
+ std::pair<iterator,iterator> equal_range(const key_type& x)
 { return m_flat_tree.equal_range(x); }

- //! Effects: Number of elements for which memory has been allocated.
- //! capacity() is always greater than or equal to size().
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- size_type capacity() const
- { return m_flat_tree.capacity(); }
-
- //! Effects: If n is less than or equal to capacity(), this call has no
- //! effect. Otherwise, it is a request for allocation of additional memory.
- //! If the request is successful, then capacity() is greater than or equal to
- //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
- //!
- //! Throws: If memory allocation allocation throws or T's copy constructor throws.
- //!
- //! Note: If capacity() is less than "count", iterators and references to
- //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
-
 /// @cond
 template <class K1, class C1, class A1>
 friend bool operator== (const flat_multiset<K1,C1,A1>&,
@@ -1279,46 +1341,48 @@
 friend bool operator< (const flat_multiset<K1,C1,A1>&,
 const flat_multiset<K1,C1,A1>&);
 private:
- iterator priv_insert(const T &x)
- { return m_flat_tree.insert_equal(x); }
-
- iterator priv_insert(const_iterator p, const T &x)
- { return m_flat_tree.insert_equal(p, x); }
+ template <class KeyType>
+ iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+ { return m_flat_tree.insert_equal(::boost::forward<KeyType>(x)); }
+
+ template <class KeyType>
+ iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+ { return m_flat_tree.insert_equal(p, ::boost::forward<KeyType>(x)); }
 /// @endcond
};

-template <class T, class Pred, class A>
-inline bool operator==(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
 { return x.m_flat_tree == y.m_flat_tree; }

-template <class T, class Pred, class A>
-inline bool operator<(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
 { return x.m_flat_tree < y.m_flat_tree; }

-template <class T, class Pred, class A>
-inline bool operator!=(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator!=(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
 { return !(x == y); }

-template <class T, class Pred, class A>
-inline bool operator>(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
 { return y < x; }

-template <class T, class Pred, class A>
-inline bool operator<=(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<=(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
 { return !(y < x); }

-template <class T, class Pred, class A>
-inline bool operator>=(const flat_multiset<T,Pred,A>& x,
- const flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>=(const flat_multiset<Key,Compare,Allocator>& x,
+ const flat_multiset<Key,Compare,Allocator>& y)
{ return !(x < y); }

-template <class T, class Pred, class A>
-inline void swap(flat_multiset<T,Pred,A>& x, flat_multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline void swap(flat_multiset<Key,Compare,Allocator>& x, flat_multiset<Key,Compare,Allocator>& y)
 { x.swap(y); }

/// @cond
@@ -1327,10 +1391,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::flat_multiset<T, C, A> >
+template <class Key, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

Modified: branches/release/boost/container/list.hpp
==============================================================================
--- branches/release/boost/container/list.hpp (original)
+++ branches/release/boost/container/list.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -7,8 +7,8 @@
// See http://www.boost.org/libs/container for documentation.
//

-#ifndef BOOST_CONTAINER_LIST_HPP_
-#define BOOST_CONTAINER_LIST_HPP_
+#ifndef BOOST_CONTAINER_LIST_HPP
+#define BOOST_CONTAINER_LIST_HPP

#if (defined _MSC_VER) && (_MSC_VER >= 1200)
# pragma once
@@ -43,13 +43,8 @@
#include <algorithm>
#include <stdexcept>

-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace boost {
-namespace container {
-#else
namespace boost {
namespace container {
-#endif

/// @cond
namespace container_detail {
@@ -73,10 +68,10 @@
 T m_data;
};

-template<class A>
+template<class Allocator>
struct intrusive_list_type
{
- typedef boost::container::allocator_traits<A> allocator_traits_type;
+ typedef boost::container::allocator_traits<Allocator> allocator_traits_type;
 typedef typename allocator_traits_type::value_type value_type;
 typedef typename boost::intrusive::pointer_traits
 <typename allocator_traits_type::pointer>::template
@@ -213,27 +208,27 @@
//! not be invalidated or made to point to different elements unless that invalidation
//! or mutation is explicit.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
class list
 : protected container_detail::node_alloc_holder
- <A, typename container_detail::intrusive_list_type<A>::type>
+ <Allocator, typename container_detail::intrusive_list_type<Allocator>::type>
{
 /// @cond
 typedef typename
- container_detail::intrusive_list_type<A>::type Icont;
- typedef container_detail::node_alloc_holder<A, Icont> AllocHolder;
- typedef typename AllocHolder::NodePtr NodePtr;
- typedef typename AllocHolder::NodeAlloc NodeAlloc;
- typedef typename AllocHolder::ValAlloc ValAlloc;
- typedef typename AllocHolder::Node Node;
- typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
- typedef typename AllocHolder::allocator_v1 allocator_v1;
- typedef typename AllocHolder::allocator_v2 allocator_v2;
- typedef typename AllocHolder::alloc_version alloc_version;
- typedef boost::container::allocator_traits<A> allocator_traits_type;
+ container_detail::intrusive_list_type<Allocator>::type Icont;
+ typedef container_detail::node_alloc_holder<Allocator, Icont> AllocHolder;
+ typedef typename AllocHolder::NodePtr NodePtr;
+ typedef typename AllocHolder::NodeAlloc NodeAlloc;
+ typedef typename AllocHolder::ValAlloc ValAlloc;
+ typedef typename AllocHolder::Node Node;
+ typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
+ typedef typename AllocHolder::allocator_v1 allocator_v1;
+ typedef typename AllocHolder::allocator_v2 allocator_v2;
+ typedef typename AllocHolder::alloc_version alloc_version;
+ typedef boost::container::allocator_traits<Allocator> allocator_traits_type;

 class equal_to_value
 {
@@ -277,19 +272,19 @@
 //
 //////////////////////////////////////////////

- typedef T value_type;
- typedef typename ::boost::container::allocator_traits<A>::pointer pointer;
- typedef typename ::boost::container::allocator_traits<A>::const_pointer const_pointer;
- typedef typename ::boost::container::allocator_traits<A>::reference reference;
- typedef typename ::boost::container::allocator_traits<A>::const_reference const_reference;
- typedef typename ::boost::container::allocator_traits<A>::size_type size_type;
- typedef typename ::boost::container::allocator_traits<A>::difference_type difference_type;
- typedef A allocator_type;
- typedef BOOST_CONTAINER_IMPDEF(NodeAlloc) stored_allocator_type;
- typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
- typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;
+ typedef T value_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(NodeAlloc) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;

 //////////////////////////////////////////////
 //
@@ -323,7 +318,7 @@
 //!
 //! Complexity: Linear to n.
 explicit list(size_type n)
- : AllocHolder(A())
+ : AllocHolder(Allocator())
 { this->resize(n); }

 //! Effects: Constructs a list that will use a copy of allocator a
@@ -333,7 +328,7 @@
 //! throws or T's default or copy constructor throws.
 //!
 //! Complexity: Linear to n.
- list(size_type n, const T& value, const A& a = A())
+ list(size_type n, const T& value, const Allocator& a = Allocator())
 : AllocHolder(a)
 { this->insert(this->cbegin(), n, value); }

@@ -393,7 +388,7 @@
 //!
 //! Complexity: Linear to the range [first, last).
 template <class InpIt>
- list(InpIt first, InpIt last, const A &a = A())
+ list(InpIt first, InpIt last, const Allocator &a = Allocator())
 : AllocHolder(a)
 { this->insert(this->cbegin(), first, last); }

@@ -506,20 +501,24 @@
 allocator_type get_allocator() const
 { return allocator_type(this->node_alloc()); }

- //! Effects: Returns a copy of the internal allocator.
+ //! Effects: Returns a reference to the internal allocator.
 //!
- //! Throws: If allocator's copy constructor throws.
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- const stored_allocator_type &get_stored_allocator() const
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
 { return this->node_alloc(); }

- //! Effects: Returns a copy of the internal allocator.
+ //! Effects: Returns a reference to the internal allocator.
 //!
- //! Throws: If allocator's copy constructor throws.
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- stored_allocator_type &get_stored_allocator()
+ //!
+ //! Note: Non-standard extension.
+ const stored_allocator_type &get_stored_allocator() const
 { return this->node_alloc(); }

 //////////////////////////////////////////////
@@ -1426,13 +1425,13 @@

};

-template <class T, class A>
-inline bool operator==(const list<T,A>& x, const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y)
{
 if(x.size() != y.size()){
 return false;
 }
- typedef typename list<T,A>::const_iterator const_iterator;
+ typedef typename list<T,Allocator>::const_iterator const_iterator;
 const_iterator end1 = x.end();

 const_iterator i1 = x.begin();
@@ -1444,39 +1443,39 @@
 return i1 == end1;
}

-template <class T, class A>
-inline bool operator<(const list<T,A>& x,
- const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator<(const list<T,Allocator>& x,
+ const list<T,Allocator>& y)
{
 return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}

-template <class T, class A>
-inline bool operator!=(const list<T,A>& x, const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y)
{
 return !(x == y);
}

-template <class T, class A>
-inline bool operator>(const list<T,A>& x, const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator>(const list<T,Allocator>& x, const list<T,Allocator>& y)
{
 return y < x;
}

-template <class T, class A>
-inline bool operator<=(const list<T,A>& x, const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y)
{
 return !(y < x);
}

-template <class T, class A>
-inline bool operator>=(const list<T,A>& x, const list<T,A>& y)
+template <class T, class Allocator>
+inline bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y)
{
 return !(x < y);
}

-template <class T, class A>
-inline void swap(list<T, A>& x, list<T, A>& y)
+template <class T, class Allocator>
+inline void swap(list<T, Allocator>& x, list<T, Allocator>& y)
{
 x.swap(y);
}
@@ -1487,10 +1486,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class A>
-struct has_trivial_destructor_after_move<boost::container::list<T, A> >
+template <class T, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::list<T, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value;
};
*/
namespace container {
@@ -1501,4 +1500,4 @@

#include <boost/container/detail/config_end.hpp>

-#endif // BOOST_CONTAINER_LIST_HPP_
+#endif // BOOST_CONTAINER_LIST_HPP

Modified: branches/release/boost/container/map.hpp
==============================================================================
--- branches/release/boost/container/map.hpp (original)
+++ branches/release/boost/container/map.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -35,24 +35,18 @@
#include <boost/static_assert.hpp>
#include <boost/container/detail/value_init.hpp>

-
-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace boost {
-namespace container {
-#else
namespace boost {
namespace container {
-#endif

/// @cond
// Forward declarations of operators == and <, needed for friend declarations.
-template <class Key, class T, class Pred, class A>
-inline bool operator==(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y);
-
-template <class Key, class T, class Pred, class A>
-inline bool operator<(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y);
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y);
+
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y);
/// @endcond

//! A map is a kind of associative container that supports unique keys (contains at
@@ -63,67 +57,63 @@
//! container and of an associative container. For a
//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
//!
-//! Pred is the ordering function for Keys (e.g. std::less<Key>).
+//! Compare is the ordering function for Keys (e.g. std::less<Key>).
//!
-//! A is the allocator to allocate the value_types
+//! Allocator is the allocator to allocate the value_types
//! (e.g. allocator< std::pair<const Key, T> > ).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Pred = std::less<Key>, class A = std::allocator< std::pair< const Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< const Key, T> > >
#else
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
#endif
class map
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(map)
- typedef container_detail::rbtree<Key,
- std::pair<const Key, T>,
- container_detail::select1st< std::pair<const Key, T> >,
- Pred,
- A> tree_t;
- tree_t m_tree; // red-black tree representing map

+ typedef std::pair<const Key, T> value_type_impl;
+ typedef container_detail::rbtree
+ <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator> tree_t;
+ typedef container_detail::pair <Key, T> movable_value_type_impl;
+ typedef container_detail::tree_value_compare
+ < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl>
+ > value_compare_impl;
+ tree_t m_tree; // red-black tree representing map
 /// @endcond

 public:
-
- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef T mapped_type;
- typedef Pred key_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
- typedef std::pair<key_type, mapped_type> nonconst_value_type;
- typedef container_detail::pair
- <key_type, mapped_type> nonconst_impl_value_type;
-
- /// @cond
- class value_compare_impl
- : public Pred,
- public std::binary_function<value_type, value_type, bool>
- {
- friend class map<Key,T,Pred,A>;
- protected :
- value_compare_impl(const Pred &c) : Pred(c) {}
- public:
- bool operator()(const value_type& x, const value_type& y) const {
- return Pred::operator()(x.first, y.first);
- }
- };
- /// @endcond
- typedef value_compare_impl value_compare;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+
+ typedef Key key_type;
+ typedef T mapped_type;
+ typedef std::pair<const Key, T> value_type;
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare;
+ typedef Compare key_compare;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;
+ typedef std::pair<key_type, mapped_type> nonconst_value_type;
+ typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl) movable_value_type;
+
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Default constructs an empty map.
 //!
@@ -132,19 +122,19 @@
 : m_tree()
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty map using the specified comparison object
 //! and allocator.
 //!
 //! Complexity: Constant.
- explicit map(const Pred& comp,
+ explicit map(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_tree(comp, a)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty map using the specified comparison object and
@@ -153,12 +143,12 @@
 //! Complexity: Linear in N if the range [first ,last ) is already sorted using
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
- map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
+ map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_tree(true, first, last, comp, a)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty map using the specified comparison object and
@@ -171,11 +161,11 @@
 //! Complexity: Linear in N.
 template <class InputIterator>
 map( ordered_unique_range_t, InputIterator first, InputIterator last
- , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
+ , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
 : m_tree(ordered_range, first, last, comp, a)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Copy constructs a map.
@@ -185,7 +175,7 @@
 : m_tree(x.m_tree)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Move constructs a map. Constructs *this using x's resources.
@@ -197,7 +187,7 @@
 : m_tree(boost::move(x.m_tree))
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Copy constructs a map using the specified allocator.
@@ -207,7 +197,7 @@
 : m_tree(x.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 A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Move constructs a map using the specified allocator.
@@ -220,7 +210,7 @@
 : m_tree(boost::move(x.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 A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Makes *this a copy of x.
@@ -235,32 +225,38 @@
 map& operator=(BOOST_RV_REF(map) x)
 { m_tree = boost::move(x.m_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return m_tree.key_comp(); }
+ allocator_type get_allocator() const
+ { return m_tree.get_allocator(); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return value_compare(m_tree.key_comp()); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return m_tree.get_stored_allocator(); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return m_tree.get_allocator(); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return m_tree.get_stored_allocator(); }

- stored_allocator_type &get_stored_allocator()
- { return m_tree.get_stored_allocator(); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -278,14 +274,6 @@
 const_iterator begin() const
 { return this->cbegin(); }

- //! Effects: Returns a const_iterator to the first element contained in the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cbegin() const
- { return m_tree.begin(); }
-
 //! Effects: Returns an iterator to the end of the container.
 //!
 //! Throws: Nothing.
@@ -302,14 +290,6 @@
 const_iterator end() const
 { return this->cend(); }

- //! Effects: Returns a const_iterator to the end of the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cend() const
- { return m_tree.end(); }
-
 //! Effects: Returns a reverse_iterator pointing to the beginning
 //! of the reversed container.
 //!
@@ -328,15 +308,6 @@
 const_reverse_iterator rbegin() const
 { return this->crbegin(); }

- //! Effects: Returns a const_reverse_iterator pointing to the beginning
- //! of the reversed container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_reverse_iterator crbegin() const
- { return m_tree.rbegin(); }
-
 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed container.
 //!
@@ -355,6 +326,31 @@
 const_reverse_iterator rend() const
 { return this->crend(); }

+ //! Effects: Returns a const_iterator to the first element contained in the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cbegin() const
+ { return m_tree.begin(); }
+
+ //! Effects: Returns a const_iterator to the end of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cend() const
+ { return m_tree.end(); }
+
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_reverse_iterator crbegin() const
+ { return m_tree.rbegin(); }
+
 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed container.
 //!
@@ -364,6 +360,12 @@
 const_reverse_iterator crend() const
 { return m_tree.rend(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -388,11 +390,17 @@
 size_type max_size() const
 { return m_tree.max_size(); }

+ //////////////////////////////////////////////
+ //
+ // element access
+ //
+ //////////////////////////////////////////////
+
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: If there is no key equivalent to x in the map, inserts
 //! value_type(x, T()) into the map.
 //!
- //! Returns: A reference to the mapped_type corresponding to x in *this.
+ //! Returns: Allocator reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
 mapped_type& operator[](const key_type &k);
@@ -400,15 +408,15 @@
 //! Effects: If there is no key equivalent to x in the map, inserts
 //! value_type(boost::move(x), T()) into the map (the key is move-constructed)
 //!
- //! Returns: A reference to the mapped_type corresponding to x in *this.
+ //! Returns: Allocator reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
 mapped_type& operator[](key_type &&k);
 #else
- BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, priv_subscript)
+ BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
 #endif

- //! Returns: A reference to the element whose key is equivalent to x.
+ //! Returns: Allocator reference to the element whose key is equivalent to x.
 //! Throws: An exception object of type out_of_range if no such element is present.
 //! Complexity: logarithmic.
 T& at(const key_type& k)
@@ -420,7 +428,7 @@
 return i->second;
 }

- //! Returns: A reference to the element whose key is equivalent to x.
+ //! Returns: Allocator reference to the element whose key is equivalent to x.
 //! Throws: An exception object of type out_of_range if no such element is present.
 //! Complexity: logarithmic.
 const T& at(const key_type& k) const
@@ -432,13 +440,11 @@
 return i->second;
 }

- //! Effects: Swaps the contents of *this and x.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- void swap(map& x)
- { m_tree.swap(x.m_tree); }
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////

 //! Effects: Inserts x if and only if there is no element in the container
 //! with key equivalent to the key of x.
@@ -481,7 +487,7 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
 { return m_tree.insert_unique(boost::move(x)); }

 //! Effects: Move constructs a new value from x if and only if there is
@@ -504,7 +510,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, const value_type& x)
+ iterator insert(const_iterator position, const value_type& x)
 { return m_tree.insert_unique(position, x); }

 //! Effects: Move constructs a new value from x if and only if there is
@@ -516,7 +522,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(nonconst_value_type) x)
 { return m_tree.insert_unique(position, boost::move(x)); }

 //! Effects: Move constructs a new value from x if and only if there is
@@ -528,7 +534,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(movable_value_type) x)
 { return m_tree.insert_unique(position, boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
@@ -537,7 +543,7 @@
 //! Returns: An iterator pointing to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- iterator insert(iterator position, const nonconst_value_type& x)
+ iterator insert(const_iterator position, const nonconst_value_type& x)
 { return m_tree.insert_unique(position, x); }

 //! Effects: Inserts an element move constructed from x in the container.
@@ -546,7 +552,7 @@
 //! Returns: An iterator pointing to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- iterator insert(iterator position, BOOST_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
 { return m_tree.insert_unique(position, boost::move(x)); }

 //! Requires: first, last are not iterators into *this.
@@ -634,6 +640,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(map& x)
+ { m_tree.swap(x.m_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -642,6 +656,32 @@
 void clear()
 { m_tree.clear(); }

+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return value_compare(m_tree.key_comp()); }
+
+ //////////////////////////////////////////////
+ //
+ // map operations
+ //
+ //////////////////////////////////////////////
+
 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
@@ -649,7 +689,7 @@
 iterator find(const key_type& x)
 { return m_tree.find(x); }

- //! Returns: A const_iterator pointing to an element with the key
+ //! Returns: Allocator const_iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.
@@ -669,7 +709,7 @@
 iterator lower_bound(const key_type& x)
 { return m_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -683,7 +723,7 @@
 iterator upper_bound(const key_type& x)
 { return m_tree.upper_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -717,7 +757,7 @@
 // i->first is greater than or equivalent to k.
 if (i == end() || key_comp()(k, (*i).first)){
 container_detail::value_init<mapped_type> m;
- nonconst_impl_value_type val(k, boost::move(m.m_t));
+ movable_value_type val(k, boost::move(m.m_t));
 i = insert(i, boost::move(val));
 }
 return (*i).second;
@@ -731,7 +771,7 @@
 // i->first is greater than or equivalent to k.
 if (i == end() || key_comp()(k, (*i).first)){
 container_detail::value_init<mapped_type> m;
- nonconst_impl_value_type val(boost::move(k), boost::move(m.m_t));
+ movable_value_type val(boost::move(k), boost::move(m.m_t));
 i = insert(i, boost::move(val));
 }
 return (*i).second;
@@ -740,60 +780,60 @@
 /// @endcond
};

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return x.m_tree == y.m_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return x.m_tree < y.m_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator!=(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator!=(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return !(x == y); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return y < x; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<=(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<=(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return !(y < x); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>=(const map<Key,T,Pred,A>& x,
- const map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>=(const map<Key,T,Compare,Allocator>& x,
+ const map<Key,T,Compare,Allocator>& y)
 { return !(x < y); }

-template <class Key, class T, class Pred, class A>
-inline void swap(map<Key,T,Pred,A>& x, map<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y)
 { x.swap(y); }

/// @cond

// Forward declaration of operators < and ==, needed for friend declaration.

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y);
-
-template <class Key, class T, class Pred, class A>
-inline bool operator<(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y);
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y);
+
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y);

} //namespace container {
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class K, class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::map<K, T, C, A> >
+template <class K, class T, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::map<K, T, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {
@@ -809,68 +849,63 @@
//! container and of an associative container. For a
//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
//!
-//! Pred is the ordering function for Keys (e.g. std::less<Key>).
+//! Compare is the ordering function for Keys (e.g. std::less<Key>).
//!
-//! A is the allocator to allocate the value_types
+//! Allocator is the allocator to allocate the value_types
//!(e.g. allocator< std::pair<const Key, T> >).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Pred = std::less<Key>, class A = std::allocator< std::pair< const Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< const Key, T> > >
#else
-template <class Key, class T, class Pred, class A>
+template <class Key, class T, class Compare, class Allocator>
#endif
class multimap
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(multimap)
- typedef container_detail::rbtree<Key,
- std::pair<const Key, T>,
- container_detail::select1st< std::pair<const Key, T> >,
- Pred,
- A> tree_t;
+
+ typedef std::pair<const Key, T> value_type_impl;
+ typedef container_detail::rbtree
+ <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator> tree_t;
+ typedef container_detail::pair <Key, T> movable_value_type_impl;
+ typedef container_detail::tree_value_compare
+ < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl>
+ > value_compare_impl;
 tree_t m_tree; // red-black tree representing map
- typedef typename container_detail::
- move_const_ref_type<Key>::type insert_key_const_ref_type;
 /// @endcond

 public:
-
- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef T mapped_type;
- typedef Pred key_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
- typedef std::pair<key_type, mapped_type> nonconst_value_type;
- typedef container_detail::pair
- <key_type, mapped_type> nonconst_impl_value_type;
-
- /// @cond
- class value_compare_impl
- : public Pred,
- public std::binary_function<value_type, value_type, bool>
- {
- friend class multimap<Key,T,Pred,A>;
- protected :
- value_compare_impl(const Pred &c) : Pred(c) {}
- public:
- bool operator()(const value_type& x, const value_type& y) const {
- return Pred::operator()(x.first, y.first);
- }
- };
- /// @endcond
- typedef value_compare_impl value_compare;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+
+ typedef Key key_type;
+ typedef T mapped_type;
+ typedef std::pair<const Key, T> value_type;
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare;
+ typedef Compare key_compare;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;
+ typedef std::pair<key_type, mapped_type> nonconst_value_type;
+ typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl) movable_value_type;
+
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Default constructs an empty multimap.
 //!
@@ -879,18 +914,18 @@
 : m_tree()
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty multimap using the specified comparison
 //! object and allocator.
 //!
 //! Complexity: Constant.
- explicit multimap(const Pred& comp, const allocator_type& a = allocator_type())
+ explicit multimap(const Compare& comp, const allocator_type& a = allocator_type())
 : m_tree(comp, a)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty multimap using the specified comparison object
@@ -900,12 +935,12 @@
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
 multimap(InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_tree(false, first, last, comp, a)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Constructs an empty multimap using the specified comparison object and
@@ -916,7 +951,7 @@
 //!
 //! Complexity: Linear in N.
 template <class InputIterator>
- multimap(ordered_range_t ordered_range, InputIterator first, InputIterator last, const Pred& comp = Pred(),
+ multimap(ordered_range_t ordered_range, InputIterator first, InputIterator last, const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_tree(ordered_range, first, last, comp, a)
 {}
@@ -928,7 +963,7 @@
 : m_tree(x.m_tree)
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Move constructs a multimap. Constructs *this using x's resources.
@@ -940,7 +975,7 @@
 : m_tree(boost::move(x.m_tree))
 {
 //Allocator type must be std::pair<CONST Key, T>
- BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Copy constructs a multimap.
@@ -950,7 +985,7 @@
 : m_tree(x.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 A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Move constructs a multimap using the specified allocator.
@@ -962,7 +997,7 @@
 : m_tree(boost::move(x.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 A::value_type>::value));
+ BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
 }

 //! Effects: Makes *this a copy of x.
@@ -977,32 +1012,38 @@
 multimap& operator=(BOOST_RV_REF(multimap) x)
 { m_tree = boost::move(x.m_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return m_tree.key_comp(); }
+ allocator_type get_allocator() const
+ { return m_tree.get_allocator(); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return value_compare(m_tree.key_comp()); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return m_tree.get_stored_allocator(); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return m_tree.get_allocator(); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return m_tree.get_stored_allocator(); }

- stored_allocator_type &get_stored_allocator()
- { return m_tree.get_stored_allocator(); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -1020,14 +1061,6 @@
 const_iterator begin() const
 { return this->cbegin(); }

- //! Effects: Returns a const_iterator to the first element contained in the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cbegin() const
- { return m_tree.begin(); }
-
 //! Effects: Returns an iterator to the end of the container.
 //!
 //! Throws: Nothing.
@@ -1044,14 +1077,6 @@
 const_iterator end() const
 { return this->cend(); }

- //! Effects: Returns a const_iterator to the end of the container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_iterator cend() const
- { return m_tree.end(); }
-
 //! Effects: Returns a reverse_iterator pointing to the beginning
 //! of the reversed container.
 //!
@@ -1070,15 +1095,6 @@
 const_reverse_iterator rbegin() const
 { return this->crbegin(); }

- //! Effects: Returns a const_reverse_iterator pointing to the beginning
- //! of the reversed container.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- const_reverse_iterator crbegin() const
- { return m_tree.rbegin(); }
-
 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed container.
 //!
@@ -1097,6 +1113,31 @@
 const_reverse_iterator rend() const
 { return this->crend(); }

+ //! Effects: Returns a const_iterator to the first element contained in the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cbegin() const
+ { return m_tree.begin(); }
+
+ //! Effects: Returns a const_iterator to the end of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_iterator cend() const
+ { return m_tree.end(); }
+
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_reverse_iterator crbegin() const
+ { return m_tree.rbegin(); }
+
 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed container.
 //!
@@ -1106,6 +1147,12 @@
 const_reverse_iterator crend() const
 { return m_tree.rend(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -1130,13 +1177,57 @@
 size_type max_size() const
 { return m_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the container.
+ //! p is a hint pointing to where the insert should start to search.
 //!
- //! Throws: Nothing.
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
 //!
- //! Complexity: Constant.
- void swap(multimap& x)
- { m_tree.swap(x.m_tree); }
+ //! Complexity: Logarithmic in general, but amortized constant if t
+ //! is inserted right before p.
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
+
+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic in general, but amortized constant if t
+ //! is inserted right before p.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
+
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_tree.emplace_hint_equal(hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));} \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

 //! Effects: Inserts x and returns the iterator pointing to the
 //! newly inserted element.
@@ -1163,7 +1254,7 @@
 //! the iterator pointing to the newly inserted element.
 //!
 //! Complexity: Logarithmic.
- iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ iterator insert(BOOST_RV_REF(movable_value_type) x)
 { return m_tree.insert_equal(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
@@ -1174,7 +1265,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, const value_type& x)
+ iterator insert(const_iterator position, const value_type& x)
 { return m_tree.insert_equal(position, x); }

 //! Effects: Inserts a new value constructed from x in the container.
@@ -1185,7 +1276,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, const nonconst_value_type& x)
+ iterator insert(const_iterator position, const nonconst_value_type& x)
 { return m_tree.insert_equal(position, x); }

 //! Effects: Inserts a new value move constructed from x in the container.
@@ -1196,7 +1287,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(nonconst_value_type) x)
 { return m_tree.insert_equal(position, boost::move(x)); }

 //! Effects: Inserts a new value move constructed from x in the container.
@@ -1207,7 +1298,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(movable_value_type) x)
 { return m_tree.insert_equal(position, boost::move(x)); }

 //! Requires: first, last are not iterators into *this.
@@ -1219,52 +1310,6 @@
 void insert(InputIterator first, InputIterator last)
 { m_tree.insert_equal(first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic in general, but amortized constant if t
- //! is inserted right before p.
- template <class... Args>
- iterator emplace(Args&&... args)
- { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the container.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic in general, but amortized constant if t
- //! is inserted right before p.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_tree.emplace_hint_equal(hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));} \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by position.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -1291,6 +1336,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(multimap& x)
+ { m_tree.swap(x.m_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -1299,6 +1352,32 @@
 void clear()
 { m_tree.clear(); }

+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return value_compare(m_tree.key_comp()); }
+
+ //////////////////////////////////////////////
+ //
+ // map operations
+ //
+ //////////////////////////////////////////////
+
 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
@@ -1306,7 +1385,7 @@
 iterator find(const key_type& x)
 { return m_tree.find(x); }

- //! Returns: A const iterator pointing to an element with the key
+ //! Returns: Allocator const iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.
@@ -1326,7 +1405,7 @@
 iterator lower_bound(const key_type& x)
 {return m_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1340,13 +1419,7 @@
 iterator upper_bound(const key_type& x)
 { return m_tree.upper_bound(x); }

- //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
- //!
- //! Complexity: Logarithmic
- std::pair<iterator,iterator> equal_range(const key_type& x)
- { return m_tree.equal_range(x); }
-
- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1356,8 +1429,13 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator,const_iterator>
- equal_range(const key_type& x) const
+ std::pair<iterator,iterator> equal_range(const key_type& x)
+ { return m_tree.equal_range(x); }
+
+ //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
+ //!
+ //! Complexity: Logarithmic
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
 { return m_tree.equal_range(x); }

 /// @cond
@@ -1371,38 +1449,38 @@
 /// @endcond
};

-template <class Key, class T, class Pred, class A>
-inline bool operator==(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator==(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return x.m_tree == y.m_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return x.m_tree < y.m_tree; }

-template <class Key, class T, class Pred, class A>
-inline bool operator!=(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return !(x == y); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return y < x; }

-template <class Key, class T, class Pred, class A>
-inline bool operator<=(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return !(y < x); }

-template <class Key, class T, class Pred, class A>
-inline bool operator>=(const multimap<Key,T,Pred,A>& x,
- const multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
+ const multimap<Key,T,Compare,Allocator>& y)
{ return !(x < y); }

-template <class Key, class T, class Pred, class A>
-inline void swap(multimap<Key,T,Pred,A>& x, multimap<Key,T,Pred,A>& y)
+template <class Key, class T, class Compare, class Allocator>
+inline void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y)
{ x.swap(y); }

/// @cond
@@ -1411,10 +1489,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class K, class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::multimap<K, T, C, A> >
+template <class K, class T, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::multimap<K, T, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

Modified: branches/release/boost/container/scoped_allocator.hpp
==============================================================================
--- branches/release/boost/container/scoped_allocator.hpp (original)
+++ branches/release/boost/container/scoped_allocator.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -47,10 +47,10 @@
//! ill-formed.
//!
//! [Example:
-//! template <class T, class A = allocator<T> >
+//! template <class T, class Allocator = allocator<T> >
//! class Z {
//! public:
-//! typedef A allocator_type;
+//! typedef Allocator allocator_type;
//!
//! // Default constructor with optional allocator suffix
//! Z(const allocator_type& a = allocator_type());
@@ -61,8 +61,8 @@
//! };
//!
//! // Specialize trait for class template Z
-//! template <class T, class A = allocator<T> >
-//! struct constructible_with_allocator_suffix<Z<T,A> >
+//! template <class T, class Allocator = allocator<T> >
+//! struct constructible_with_allocator_suffix<Z<T,Allocator> >
//! : ::boost::true_type { };
//! -- end example]
//!
@@ -91,10 +91,10 @@
//! a constructor, then the program is ill-formed.
//!
//! [Example:
-//! template <class T, class A = allocator<T> >
+//! template <class T, class Allocator = allocator<T> >
//! class Y {
//! public:
-//! typedef A allocator_type;
+//! typedef Allocator allocator_type;
//!
//! // Default constructor with and allocator-extended default constructor
//! Y();
@@ -111,8 +111,8 @@
//! };
//!
//! // Specialize trait for class template Y
-//! template <class T, class A = allocator<T> >
-//! struct constructible_with_allocator_prefix<Y<T,A> >
+//! template <class T, class Allocator = allocator<T> >
+//! struct constructible_with_allocator_prefix<Y<T,Allocator> >
//! : ::boost::true_type { };
//!
//! -- end example]
@@ -1036,16 +1036,16 @@
 typedef typename outer_traits_type::const_pointer const_pointer;
 typedef typename outer_traits_type::void_pointer void_pointer;
 typedef typename outer_traits_type::const_void_pointer const_void_pointer;
- //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_copy_assignment::value` is
- //! true for any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+ //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value` is
+ //! true for any `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
 typedef typename base_type::
 propagate_on_container_copy_assignment propagate_on_container_copy_assignment;
- //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_move_assignment::value` is
- //! true for any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+ //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_move_assignment::value` is
+ //! true for any `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
 typedef typename base_type::
 propagate_on_container_move_assignment propagate_on_container_move_assignment;
- //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_swap::value` is true for any
- //! `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+ //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_swap::value` is true for any
+ //! `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
 typedef typename base_type::
 propagate_on_container_swap propagate_on_container_swap;

@@ -1211,9 +1211,9 @@
 outer_traits_type::deallocate(this->outer_allocator(), p, n);
 }

- //! Returns: A new scoped_allocator_adaptor object where each allocator
+ //! Returns: Allocator new scoped_allocator_adaptor object where each allocator
 //! A in the adaptor is initialized from the result of calling
- //! `allocator_traits<A>::select_on_container_copy_construction()` on
+ //! `allocator_traits<Allocator>::select_on_container_copy_construction()` on
 //! the corresponding allocator in *this.
 scoped_allocator_adaptor select_on_container_copy_construction() const
 {

Modified: branches/release/boost/container/set.hpp
==============================================================================
--- branches/release/boost/container/set.hpp (original)
+++ branches/release/boost/container/set.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -24,6 +24,7 @@
#include <memory>

#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/detail/tree.hpp>
#include <boost/move/move.hpp>
@@ -31,23 +32,18 @@
#include <boost/container/detail/preprocessor.hpp>
#endif

-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
namespace container {
-#else
-namespace boost {
-namespace container {
-#endif

/// @cond
// Forward declarations of operators < and ==, needed for friend declaration.
-template <class T, class Pred, class A>
-inline bool operator==(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y);
-
-template <class T, class Pred, class A>
-inline bool operator<(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y);
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y);
+
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y);
/// @endcond

//! A set is a kind of associative container that supports unique keys (contains at
@@ -58,41 +54,48 @@
//! , and of an associative container. A set also provides most operations described in
//! for unique keys.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class set
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(set)
- typedef container_detail::rbtree<T, T,
- container_detail::identity<T>, Pred, A> tree_t;
+ typedef container_detail::rbtree<Key, Key,
+ container_detail::identity<Key>, Compare, Allocator> tree_t;
 tree_t m_tree; // red-black tree representing set
- typedef typename container_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 /// @endcond

 public:
-
- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef Pred key_compare;
- typedef Pred value_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef Key value_type;
+ typedef Compare key_compare;
+ typedef Compare value_compare;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;
+
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Default constructs an empty set.
 //!
@@ -105,7 +108,7 @@
 //! and allocator.
 //!
 //! Complexity: Constant.
- explicit set(const Pred& comp,
+ explicit set(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_tree(comp, a)
 {}
@@ -116,7 +119,7 @@
 //! Complexity: Linear in N if the range [first ,last ) is already sorted using
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
- set(InputIterator first, InputIterator last, const Pred& comp = Pred(),
+ set(InputIterator first, InputIterator last, const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_tree(true, first, last, comp, a)
 {}
@@ -131,7 +134,7 @@
 //! Complexity: Linear in N.
 template <class InputIterator>
 set( ordered_unique_range_t, InputIterator first, InputIterator last
- , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
+ , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
 : m_tree(ordered_range, first, last, comp, a)
 {}

@@ -178,20 +181,6 @@
 set& operator=(BOOST_RV_REF(set) x)
 { m_tree = boost::move(x.m_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
- //!
- //! Complexity: Constant.
- key_compare key_comp() const
- { return m_tree.key_comp(); }
-
- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
- //!
- //! Complexity: Constant.
- value_compare value_comp() const
- { return m_tree.key_comp(); }
-
 //! Effects: Returns a copy of the Allocator that
 //! was passed to the object's constructor.
 //!
@@ -199,12 +188,32 @@
 allocator_type get_allocator() const
 { return m_tree.get_allocator(); }

+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
+ //!
+ //! Complexity: Constant.
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return m_tree.get_stored_allocator(); }

+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
+ //!
+ //! Complexity: Constant.
+ //!
+ //! Note: Non-standard extension.
 stored_allocator_type &get_stored_allocator()
 { return m_tree.get_stored_allocator(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns an iterator to the first element contained in the container.
 //!
 //! Throws: Nothing.
@@ -307,6 +316,12 @@
 const_reverse_iterator crend() const
 { return m_tree.crend(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -331,90 +346,15 @@
 size_type max_size() const
 { return m_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
- //!
- //! Throws: Nothing.
- //!
- //! Complexity: Constant.
- void swap(set& x)
- { m_tree.swap(x.m_tree); }
-
- //! Effects: Inserts x if and only if there is no element in the container
- //! with key equivalent to the key of x.
- //!
- //! Returns: The bool component of the returned pair is true if and only
- //! if the insertion takes place, and the iterator component of the pair
- //! points to the element with key equivalent to the key of x.
- //!
- //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(insert_const_ref_type x)
- { return priv_insert(x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- std::pair<iterator,bool> insert(T &x)
- { return this->insert(const_cast<const T &>(x)); }
-
- template<class U>
- std::pair<iterator,bool> insert(const U &u
- , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(u); }
- #endif
-
- //! Effects: Move constructs a new value from x if and only if there is
- //! no element in the container with key equivalent to the key of x.
- //!
- //! Returns: The bool component of the returned pair is true if and only
- //! if the insertion takes place, and the iterator component of the pair
- //! points to the element with key equivalent to the key of x.
- //!
- //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
- { return m_tree.insert_unique(boost::move(x)); }
-
- //! Effects: Inserts a copy of x in the container if and only if there is
- //! no element in the container with key equivalent to the key of x.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic in general, but amortized constant if t
- //! is inserted right before p.
- iterator insert(const_iterator p, insert_const_ref_type x)
- { return priv_insert(p, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert( const_iterator position, const U &u
- , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(position, u); }
- #endif
-
- //! Effects: Inserts an element move constructed from x in the container.
- //! p is a hint pointing to where the insert should start to search.
- //!
- //! Returns: An iterator pointing to the element with key equivalent to the key of x.
- //!
- //! Complexity: Logarithmic.
- iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
- { return m_tree.insert_unique(p, boost::move(x)); }
-
- //! Requires: first, last are not iterators into *this.
- //!
- //! Effects: inserts each element from the range [first,last) if and only
- //! if there is no element with key equivalent to the key of that element.
- //!
- //! Complexity: At most N log(size()+N) (N is the distance from first to last)
- template <class InputIterator>
- void insert(InputIterator first, InputIterator last)
- { m_tree.insert_unique(first, last); }
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////

 #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

- //! Effects: Inserts an object x of type T constructed with
+ //! Effects: Inserts an object x of type Key constructed with
 //! std::forward<Args>(args)... if and only if there is
 //! no element in the container with equivalent value.
 //! and returns the iterator pointing to the
@@ -425,14 +365,14 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Throws: If memory allocation throws or
- //! T's in-place constructor throws.
+ //! Key's in-place constructor throws.
 //!
 //! Complexity: Logarithmic.
 template <class... Args>
 std::pair<iterator,bool> emplace(Args&&... args)
 { return m_tree.emplace_unique(boost::forward<Args>(args)...); }

- //! Effects: Inserts an object of type T constructed with
+ //! Effects: Inserts an object of type Key constructed with
 //! std::forward<Args>(args)... if and only if there is
 //! no element in the container with equivalent value.
 //! p is a hint pointing to where the insert
@@ -463,6 +403,66 @@

 #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+ //! Effects: Inserts x if and only if there is no element in the container
+ //! with key equivalent to the key of x.
+ //!
+ //! Returns: The bool component of the returned pair is true if and only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
+ //!
+ //! Complexity: Logarithmic.
+ std::pair<iterator, bool> insert(const value_type &x);
+
+ //! Effects: Move constructs a new value from x if and only if there is
+ //! no element in the container with key equivalent to the key of x.
+ //!
+ //! Returns: The bool component of the returned pair is true if and only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
+ //!
+ //! Complexity: Logarithmic.
+ std::pair<iterator, bool> insert(value_type &&x);
+ #else
+ private:
+ typedef std::pair<iterator, bool> insert_return_pair;
+ public:
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->priv_insert)
+ #endif
+
+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+ //! Effects: Inserts a copy of x in the container if and only if there is
+ //! no element in the container with key equivalent to the key of x.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic in general, but amortized constant if t
+ //! is inserted right before p.
+ iterator insert(const_iterator p, const value_type &x);
+
+ //! Effects: Inserts an element move constructed from x in the container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! Returns: An iterator pointing to the element with key equivalent to the key of x.
+ //!
+ //! Complexity: Logarithmic.
+ iterator insert(const_iterator position, value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
+ #endif
+
+ //! Requires: first, last are not iterators into *this.
+ //!
+ //! Effects: inserts each element from the range [first,last) if and only
+ //! if there is no element with key equivalent to the key of that element.
+ //!
+ //! Complexity: At most N log(size()+N) (N is the distance from first to last)
+ template <class InputIterator>
+ void insert(InputIterator first, InputIterator last)
+ { m_tree.insert_unique(first, last); }
+
 //! Effects: Erases the element pointed to by p.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -489,6 +489,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(set& x)
+ { m_tree.swap(x.m_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -497,6 +505,32 @@
 void clear()
 { m_tree.clear(); }

+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return m_tree.key_comp(); }
+
+ //////////////////////////////////////////////
+ //
+ // set operations
+ //
+ //////////////////////////////////////////////
+
 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
@@ -504,7 +538,7 @@
 iterator find(const key_type& x)
 { return m_tree.find(x); }

- //! Returns: A const_iterator pointing to an element with the key
+ //! Returns: Allocator const_iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.
@@ -524,7 +558,7 @@
 iterator lower_bound(const key_type& x)
 { return m_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -538,7 +572,7 @@
 iterator upper_bound(const key_type& x)
 { return m_tree.upper_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -548,15 +582,13 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<iterator,iterator>
- equal_range(const key_type& x)
+ std::pair<iterator,iterator> equal_range(const key_type& x)
 { return m_tree.equal_range(x); }

 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator, const_iterator>
- equal_range(const key_type& x) const
+ std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
 { return m_tree.equal_range(x); }

 /// @cond
@@ -567,47 +599,48 @@
 friend bool operator< (const set<K1,C1,A1>&, const set<K1,C1,A1>&);

 private:
- std::pair<iterator, bool> priv_insert(const T &x)
- { return m_tree.insert_unique(x); }
-
- iterator priv_insert(const_iterator p, const T &x)
- { return m_tree.insert_unique(p, x); }
-
+ template <class KeyType>
+ std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+ { return m_tree.insert_unique(::boost::forward<KeyType>(x)); }
+
+ template <class KeyType>
+ iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+ { return m_tree.insert_unique(p, ::boost::forward<KeyType>(x)); }
 /// @endcond
};

-template <class T, class Pred, class A>
-inline bool operator==(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return x.m_tree == y.m_tree; }

-template <class T, class Pred, class A>
-inline bool operator<(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return x.m_tree < y.m_tree; }

-template <class T, class Pred, class A>
-inline bool operator!=(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator!=(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return !(x == y); }

-template <class T, class Pred, class A>
-inline bool operator>(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return y < x; }

-template <class T, class Pred, class A>
-inline bool operator<=(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<=(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return !(y < x); }

-template <class T, class Pred, class A>
-inline bool operator>=(const set<T,Pred,A>& x,
- const set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>=(const set<Key,Compare,Allocator>& x,
+ const set<Key,Compare,Allocator>& y)
{ return !(x < y); }

-template <class T, class Pred, class A>
-inline void swap(set<T,Pred,A>& x, set<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y)
{ x.swap(y); }

/// @cond
@@ -616,23 +649,23 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::set<T, C, A> >
+template <class Key, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::set<Key, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

// Forward declaration of operators < and ==, needed for friend declaration.

-template <class T, class Pred, class A>
-inline bool operator==(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y);
-
-template <class T, class Pred, class A>
-inline bool operator<(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y);
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y);
+
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y);
/// @endcond

//! A multiset is a kind of associative container that supports equivalent keys
@@ -643,41 +676,49 @@
//! container, and of an associative container). multiset also provides most operations
//! described for duplicate keys.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
+template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
#else
-template <class T, class Pred, class A>
+template <class Key, class Compare, class Allocator>
#endif
class multiset
{
 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(multiset)
- typedef container_detail::rbtree<T, T,
- container_detail::identity<T>, Pred, A> tree_t;
+ typedef container_detail::rbtree<Key, Key,
+ container_detail::identity<Key>, Compare, Allocator> tree_t;
 tree_t m_tree; // red-black tree representing multiset
- typedef typename container_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 /// @endcond

 public:

- // typedefs:
- typedef typename tree_t::key_type key_type;
- typedef typename tree_t::value_type value_type;
- typedef typename tree_t::pointer pointer;
- typedef typename tree_t::const_pointer const_pointer;
- typedef typename tree_t::reference reference;
- typedef typename tree_t::const_reference const_reference;
- typedef Pred key_compare;
- typedef Pred value_compare;
- typedef typename tree_t::iterator iterator;
- typedef typename tree_t::const_iterator const_iterator;
- typedef typename tree_t::reverse_iterator reverse_iterator;
- typedef typename tree_t::const_reverse_iterator const_reverse_iterator;
- typedef typename tree_t::size_type size_type;
- typedef typename tree_t::difference_type difference_type;
- typedef typename tree_t::allocator_type allocator_type;
- typedef typename tree_t::stored_allocator_type stored_allocator_type;
+ //////////////////////////////////////////////
+ //
+ // types
+ //
+ //////////////////////////////////////////////
+ typedef Key key_type;
+ typedef Key value_type;
+ typedef Compare key_compare;
+ typedef Compare value_compare;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type) stored_allocator_type;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator) iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator) const_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator) reverse_iterator;
+ typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator) const_reverse_iterator;
+
+ //////////////////////////////////////////////
+ //
+ // construct/copy/destroy
+ //
+ //////////////////////////////////////////////

 //! Effects: Constructs an empty multiset using the specified comparison
 //! object and allocator.
@@ -691,7 +732,7 @@
 //! object and allocator.
 //!
 //! Complexity: Constant.
- explicit multiset(const Pred& comp,
+ explicit multiset(const Compare& comp,
 const allocator_type& a = allocator_type())
 : m_tree(comp, a)
 {}
@@ -703,7 +744,7 @@
 //! comp and otherwise N logN, where N is last - first.
 template <class InputIterator>
 multiset(InputIterator first, InputIterator last,
- const Pred& comp = Pred(),
+ const Compare& comp = Compare(),
 const allocator_type& a = allocator_type())
 : m_tree(false, first, last, comp, a)
 {}
@@ -717,7 +758,7 @@
 //! Complexity: Linear in N.
 template <class InputIterator>
 multiset( ordered_range_t ordered_range, InputIterator first, InputIterator last
- , const Pred& comp = Pred()
+ , const Compare& comp = Compare()
 , const allocator_type& a = allocator_type())
 : m_tree(ordered_range, first, last, comp, a)
 {}
@@ -767,32 +808,38 @@
 multiset& operator=(BOOST_RV_REF(multiset) x)
 { m_tree = boost::move(x.m_tree); return *this; }

- //! Effects: Returns the comparison object out
- //! of which a was constructed.
+ //! Effects: Returns a copy of the Allocator that
+ //! was passed to the object's constructor.
 //!
 //! Complexity: Constant.
- key_compare key_comp() const
- { return m_tree.key_comp(); }
+ allocator_type get_allocator() const
+ { return m_tree.get_allocator(); }

- //! Effects: Returns an object of value_compare constructed out
- //! of the comparison object.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- value_compare value_comp() const
- { return m_tree.key_comp(); }
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
+ { return m_tree.get_stored_allocator(); }

- //! Effects: Returns a copy of the Allocator that
- //! was passed to the object's constructor.
+ //! Effects: Returns a reference to the internal allocator.
+ //!
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- allocator_type get_allocator() const
- { return m_tree.get_allocator(); }
-
+ //!
+ //! Note: Non-standard extension.
 const stored_allocator_type &get_stored_allocator() const
 { return m_tree.get_stored_allocator(); }

- stored_allocator_type &get_stored_allocator()
- { return m_tree.get_stored_allocator(); }
+ //////////////////////////////////////////////
+ //
+ // iterators
+ //
+ //////////////////////////////////////////////

 //! Effects: Returns an iterator to the first element contained in the container.
 //!
@@ -896,6 +943,12 @@
 const_reverse_iterator crend() const
 { return m_tree.crend(); }

+ //////////////////////////////////////////////
+ //
+ // capacity
+ //
+ //////////////////////////////////////////////
+
 //! Effects: Returns true if the container contains no elements.
 //!
 //! Throws: Nothing.
@@ -920,30 +973,62 @@
 size_type max_size() const
 { return m_tree.max_size(); }

- //! Effects: Swaps the contents of *this and x.
+ //////////////////////////////////////////////
+ //
+ // modifiers
+ //
+ //////////////////////////////////////////////
+
+ #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+ //! Effects: Inserts an object of type Key constructed with
+ //! std::forward<Args>(args)... and returns the iterator pointing to the
+ //! newly inserted element.
 //!
- //! Throws: Nothing.
+ //! Complexity: Logarithmic.
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
+
+ //! Effects: Inserts an object of type Key constructed with
+ //! std::forward<Args>(args)...
 //!
- //! Complexity: Constant.
- void swap(multiset& x)
- { m_tree.swap(x.m_tree); }
+ //! Returns: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! Complexity: Logarithmic in general, but amortized constant if t
+ //! is inserted right before p.
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
+
+ #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+ #define BOOST_PP_LOCAL_MACRO(n) \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
+ \
+ BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+ iterator emplace_hint(const_iterator hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+ { return m_tree.emplace_hint_equal(hint \
+ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));} \
+ //!
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+ #include BOOST_PP_LOCAL_ITERATE()

+ #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+
+
+
+
+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: Inserts x and returns the iterator pointing to the
 //! newly inserted element.
 //!
 //! Complexity: Logarithmic.
- iterator insert(insert_const_ref_type x)
- { return priv_insert(x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(T &x)
- { return this->insert(const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const U &u
- , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(u); }
- #endif
+ iterator insert(const value_type &x);

 //! Effects: Inserts a copy of x in the container.
 //!
@@ -952,9 +1037,12 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(BOOST_RV_REF(value_type) x)
- { return m_tree.insert_equal(boost::move(x)); }
+ iterator insert(value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, iterator, this->priv_insert)
+ #endif

+ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
 //!
@@ -963,18 +1051,7 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(const_iterator p, insert_const_ref_type x)
- { return priv_insert(p, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert( const_iterator position, const U &u
- , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
- { return priv_insert(position, u); }
- #endif
+ iterator insert(const_iterator p, const value_type &x);

 //! Effects: Inserts a value move constructed from x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -984,8 +1061,10 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
- { return m_tree.insert_equal(p, boost::move(x)); }
+ iterator insert(const_iterator position, value_type &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
+ #endif

 //! Requires: first, last are not iterators into *this.
 //!
@@ -996,47 +1075,6 @@
 void insert(InputIterator first, InputIterator last)
 { m_tree.insert_equal(first, last); }

- #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... and returns the iterator pointing to the
- //! newly inserted element.
- //!
- //! Complexity: Logarithmic.
- template <class... Args>
- iterator emplace(Args&&... args)
- { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
-
- //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)...
- //!
- //! Returns: An iterator pointing to the element with key equivalent
- //! to the key of x.
- //!
- //! Complexity: Logarithmic in general, but amortized constant if t
- //! is inserted right before p.
- template <class... Args>
- iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
-
- #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
- #define BOOST_PP_LOCAL_MACRO(n) \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \
- \
- BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
- iterator emplace_hint(const_iterator hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
- { return m_tree.emplace_hint_equal(hint \
- BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));} \
- //!
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-
 //! Effects: Erases the element pointed to by p.
 //!
 //! Returns: Returns an iterator pointing to the element immediately
@@ -1063,6 +1101,14 @@
 iterator erase(const_iterator first, const_iterator last)
 { return m_tree.erase(first, last); }

+ //! Effects: Swaps the contents of *this and x.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ void swap(multiset& x)
+ { m_tree.swap(x.m_tree); }
+
 //! Effects: erase(a.begin(),a.end()).
 //!
 //! Postcondition: size() == 0.
@@ -1071,6 +1117,32 @@
 void clear()
 { m_tree.clear(); }

+ //////////////////////////////////////////////
+ //
+ // observers
+ //
+ //////////////////////////////////////////////
+
+ //! Effects: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! Complexity: Constant.
+ key_compare key_comp() const
+ { return m_tree.key_comp(); }
+
+ //! Effects: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! Complexity: Constant.
+ value_compare value_comp() const
+ { return m_tree.key_comp(); }
+
+ //////////////////////////////////////////////
+ //
+ // set operations
+ //
+ //////////////////////////////////////////////
+
 //! Returns: An iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
@@ -1078,7 +1150,7 @@
 iterator find(const key_type& x)
 { return m_tree.find(x); }

- //! Returns: A const iterator pointing to an element with the key
+ //! Returns: Allocator const iterator pointing to an element with the key
 //! equivalent to x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic.
@@ -1098,7 +1170,7 @@
 iterator lower_bound(const key_type& x)
 { return m_tree.lower_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than k, or a.end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1112,7 +1184,7 @@
 iterator upper_bound(const key_type& x)
 { return m_tree.upper_bound(x); }

- //! Returns: A const iterator pointing to the first element with key not
+ //! Returns: Allocator const iterator pointing to the first element with key not
 //! less than x, or end() if such an element is not found.
 //!
 //! Complexity: Logarithmic
@@ -1122,15 +1194,13 @@
 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<iterator,iterator>
- equal_range(const key_type& x)
+ std::pair<iterator,iterator> equal_range(const key_type& x)
 { return m_tree.equal_range(x); }

 //! Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
 //!
 //! Complexity: Logarithmic
- std::pair<const_iterator, const_iterator>
- equal_range(const key_type& x) const
+ std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
 { return m_tree.equal_range(x); }

 /// @cond
@@ -1141,47 +1211,49 @@
 friend bool operator< (const multiset<K1,C1,A1>&,
 const multiset<K1,C1,A1>&);
 private:
- iterator priv_insert(const T &x)
- { return m_tree.insert_equal(x); }
-
- iterator priv_insert(const_iterator p, const T &x)
- { return m_tree.insert_equal(p, x); }
+ template <class KeyType>
+ iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+ { return m_tree.insert_equal(::boost::forward<KeyType>(x)); }
+
+ template <class KeyType>
+ iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+ { return m_tree.insert_equal(p, ::boost::forward<KeyType>(x)); }

 /// @endcond
};

-template <class T, class Pred, class A>
-inline bool operator==(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator==(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return x.m_tree == y.m_tree; }

-template <class T, class Pred, class A>
-inline bool operator<(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return x.m_tree < y.m_tree; }

-template <class T, class Pred, class A>
-inline bool operator!=(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator!=(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return !(x == y); }

-template <class T, class Pred, class A>
-inline bool operator>(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return y < x; }

-template <class T, class Pred, class A>
-inline bool operator<=(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator<=(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return !(y < x); }

-template <class T, class Pred, class A>
-inline bool operator>=(const multiset<T,Pred,A>& x,
- const multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline bool operator>=(const multiset<Key,Compare,Allocator>& x,
+ const multiset<Key,Compare,Allocator>& y)
{ return !(x < y); }

-template <class T, class Pred, class A>
-inline void swap(multiset<T,Pred,A>& x, multiset<T,Pred,A>& y)
+template <class Key, class Compare, class Allocator>
+inline void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y)
{ x.swap(y); }

/// @cond
@@ -1190,10 +1262,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class C, class A>
-struct has_trivial_destructor_after_move<boost::container::multiset<T, C, A> >
+template <class Key, class C, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::multiset<Key, C, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value && has_trivial_destructor<C>::value;
};
*/
namespace container {

Modified: branches/release/boost/container/slist.hpp
==============================================================================
--- branches/release/boost/container/slist.hpp (original)
+++ branches/release/boost/container/slist.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -44,17 +44,12 @@
#include <functional>
#include <algorithm>

-#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace boost {
-namespace container {
-#else
namespace boost {
namespace container {
-#endif

/// @cond

-template <class T, class A>
+template <class T, class Allocator>
class slist;

namespace container_detail {
@@ -78,10 +73,10 @@
 T m_data;
};

-template<class A>
+template<class Allocator>
struct intrusive_slist_type
{
- typedef boost::container::allocator_traits<A> allocator_traits_type;
+ typedef boost::container::allocator_traits<Allocator> allocator_traits_type;
 typedef typename allocator_traits_type::value_type value_type;
 typedef typename boost::intrusive::pointer_traits
 <typename allocator_traits_type::pointer>::template
@@ -230,18 +225,18 @@
//! needs, and that you often need to use insert and erase in the middle of the list,
//! then you should probably use list instead of slist.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
class slist
 : protected container_detail::node_alloc_holder
- <A, typename container_detail::intrusive_slist_type<A>::type>
+ <Allocator, typename container_detail::intrusive_slist_type<Allocator>::type>
{
 /// @cond
 typedef typename
- container_detail::intrusive_slist_type<A>::type Icont;
- typedef container_detail::node_alloc_holder<A, Icont> AllocHolder;
+ container_detail::intrusive_slist_type<Allocator>::type Icont;
+ typedef container_detail::node_alloc_holder<Allocator, Icont> AllocHolder;
 typedef typename AllocHolder::NodePtr NodePtr;
 typedef typename AllocHolder::NodeAlloc NodeAlloc;
 typedef typename AllocHolder::ValAlloc ValAlloc;
@@ -250,7 +245,7 @@
 typedef typename AllocHolder::allocator_v1 allocator_v1;
 typedef typename AllocHolder::allocator_v2 allocator_v2;
 typedef typename AllocHolder::alloc_version alloc_version;
- typedef boost::container::allocator_traits<A> allocator_traits_type;
+ typedef boost::container::allocator_traits<Allocator> allocator_traits_type;

 class equal_to_value
 {
@@ -294,13 +289,13 @@
 //////////////////////////////////////////////

 typedef T value_type;
- typedef typename ::boost::container::allocator_traits<A>::pointer pointer;
- typedef typename ::boost::container::allocator_traits<A>::const_pointer const_pointer;
- typedef typename ::boost::container::allocator_traits<A>::reference reference;
- typedef typename ::boost::container::allocator_traits<A>::const_reference const_reference;
- typedef typename ::boost::container::allocator_traits<A>::size_type size_type;
- typedef typename ::boost::container::allocator_traits<A>::difference_type difference_type;
- typedef A allocator_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
 typedef BOOST_CONTAINER_IMPDEF(NodeAlloc) stored_allocator_type;
 typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
 typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
@@ -519,12 +514,14 @@
 allocator_type get_allocator() const
 { return allocator_type(this->node_alloc()); }

- //! Effects: Returns a copy of the internal allocator.
+ //! Effects: Returns a reference to the internal allocator.
 //!
- //! Throws: If allocator's copy constructor throws.
+ //! Throws: Nothing
 //!
 //! Complexity: Constant.
- const stored_allocator_type &get_stored_allocator() const
+ //!
+ //! Note: Non-standard extension.
+ stored_allocator_type &get_stored_allocator()
 { return this->node_alloc(); }

 //! Effects: Returns a reference to the internal allocator.
@@ -534,7 +531,7 @@
 //! Complexity: Constant.
 //!
 //! Note: Non-standard extension.
- stored_allocator_type &get_stored_allocator()
+ const stored_allocator_type &get_stored_allocator() const
 { return this->node_alloc(); }

 //////////////////////////////////////////////
@@ -1605,14 +1602,14 @@
 /// @endcond
};

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator==(const slist<T,A>& x, const slist<T,A>& y)
+operator==(const slist<T,Allocator>& x, const slist<T,Allocator>& y)
{
 if(x.size() != y.size()){
 return false;
 }
- typedef typename slist<T,A>::const_iterator const_iterator;
+ typedef typename slist<T,Allocator>::const_iterator const_iterator;
 const_iterator end1 = x.end();

 const_iterator i1 = x.begin();
@@ -1624,36 +1621,36 @@
 return i1 == end1;
}

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator<(const slist<T,A>& sL1, const slist<T,A>& sL2)
+operator<(const slist<T,Allocator>& sL1, const slist<T,Allocator>& sL2)
{
 return std::lexicographical_compare
 (sL1.begin(), sL1.end(), sL2.begin(), sL2.end());
}

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator!=(const slist<T,A>& sL1, const slist<T,A>& sL2)
+operator!=(const slist<T,Allocator>& sL1, const slist<T,Allocator>& sL2)
 { return !(sL1 == sL2); }

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator>(const slist<T,A>& sL1, const slist<T,A>& sL2)
+operator>(const slist<T,Allocator>& sL1, const slist<T,Allocator>& sL2)
 { return sL2 < sL1; }

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator<=(const slist<T,A>& sL1, const slist<T,A>& sL2)
+operator<=(const slist<T,Allocator>& sL1, const slist<T,Allocator>& sL2)
 { return !(sL2 < sL1); }

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator>=(const slist<T,A>& sL1, const slist<T,A>& sL2)
+operator>=(const slist<T,Allocator>& sL1, const slist<T,Allocator>& sL2)
 { return !(sL1 < sL2); }

-template <class T, class A>
-inline void swap(slist<T,A>& x, slist<T,A>& y)
+template <class T, class Allocator>
+inline void swap(slist<T,Allocator>& x, slist<T,Allocator>& y)
 { x.swap(y); }

}}
@@ -1664,10 +1661,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class A>
-struct has_trivial_destructor_after_move<boost::container::slist<T, A> >
+template <class T, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::slist<T, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value;
};
*/
namespace container {
@@ -1685,11 +1682,11 @@
//there is no other way
namespace std {

-template <class T, class A>
-class insert_iterator<boost::container::slist<T, A> >
+template <class T, class Allocator>
+class insert_iterator<boost::container::slist<T, Allocator> >
{
 protected:
- typedef boost::container::slist<T, A> Container;
+ typedef boost::container::slist<T, Allocator> Container;
 Container* container;
 typename Container::iterator iter;
 public:
@@ -1722,4 +1719,4 @@

#include <boost/container/detail/config_end.hpp>

-#endif /* BOOST_CONTAINER_SLIST_HPP */
+#endif // BOOST_CONTAINER_SLIST_HPP

Modified: branches/release/boost/container/stable_vector.hpp
==============================================================================
--- branches/release/boost/container/stable_vector.hpp (original)
+++ branches/release/boost/container/stable_vector.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -275,26 +275,6 @@
 node_ptr pn;
};

-template<class A, unsigned int Version>
-struct select_multiallocation_chain
-{
- typedef typename A::multiallocation_chain type;
-};
-
-template<class A>
-struct select_multiallocation_chain<A, 1>
-{
- typedef typename boost::intrusive::pointer_traits
- <typename allocator_traits<A>::pointer>::
- template rebind_pointer<void>::type void_ptr;
- typedef container_detail::basic_multiallocation_chain
- <void_ptr> multialloc_cached_counted;
- typedef boost::container::container_detail::
- transform_multiallocation_chain
- < multialloc_cached_counted
- , typename allocator_traits<A>::value_type> type;
-};
-
template<class VoidPtr, class VoidAllocator>
struct index_traits
{
@@ -386,6 +366,89 @@
 #endif //STABLE_VECTOR_ENABLE_INVARIANT_CHECKING
};

+template<class Allocator, unsigned Version = boost::container::container_detail::version<Allocator>::value>
+struct allocator_version_wrapper
+{
+ typedef ::boost::container::container_detail::integral_constant
+ <unsigned, Version> alloc_version;
+
+ typedef typename Allocator::multiallocation_chain multiallocation_chain;
+
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+
+ static pointer allocate_one(Allocator &a)
+ { return a.allocate_one(); }
+
+ static void deallocate_one(Allocator &a, const pointer &p)
+ { a.deallocate_one(p); }
+
+ static multiallocation_chain allocate_individual(Allocator &a, size_type n)
+ { return a.allocate_individual(n); }
+
+ static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+ { a.deallocate_individual(::boost::move(holder)); }
+};
+
+template<class Allocator>
+struct allocator_version_wrapper<Allocator, 1>
+{
+ typedef ::boost::container::container_detail::integral_constant
+ <unsigned, 1> alloc_version;
+
+ typedef typename boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename boost::container::allocator_traits<Allocator>::value_type value_type;
+
+ typedef typename boost::intrusive::pointer_traits<pointer>::
+ template rebind_pointer<void>::type void_ptr;
+ typedef container_detail::basic_multiallocation_chain
+ <void_ptr> multialloc_cached_counted;
+ typedef boost::container::container_detail::
+ transform_multiallocation_chain
+ < multialloc_cached_counted, value_type> multiallocation_chain;
+
+ static pointer allocate_one(Allocator &a)
+ { return a.allocate(1); }
+
+ static void deallocate_one(Allocator &a, const pointer &p)
+ { a.deallocate(p, 1); }
+
+ static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+ {
+ while(!holder.empty()){
+ a.deallocate(holder.pop_front(), 1);
+ }
+ }
+
+ struct allocate_individual_rollback
+ {
+ allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
+ : mr_a(a), mr_chain(chain)
+ {}
+
+ ~allocate_individual_rollback()
+ {
+ allocator_version_wrapper::deallocate_individual(mr_a, mr_chain);
+ }
+
+ Allocator &mr_a;
+ multiallocation_chain &mr_chain;
+ };
+
+ static multiallocation_chain allocate_individual(Allocator &a, size_type n)
+ {
+ multiallocation_chain m;
+ multiallocation_chain m_ret;
+ allocate_individual_rollback rollback(a, m);
+ while(n--){
+ m.push_front(a.allocate(1));
+ }
+ m.swap(m_ret);
+ return ::boost::move(m_ret);
+ }
+};
+
} //namespace stable_vector_detail

#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -438,14 +501,14 @@
//! Exception safety: As stable_vector does not internally copy elements around, some
//! operations provide stronger exception safety guarantees than in std::vector.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
class stable_vector
{
 ///@cond
- typedef allocator_traits<A> allocator_traits_type;
+ typedef allocator_traits<Allocator> allocator_traits_type;
 typedef typename boost::intrusive::pointer_traits
 <typename allocator_traits_type::pointer>::
 template rebind_pointer<void>::type void_ptr;
@@ -487,125 +550,35 @@
 integral_constant<unsigned, 2> allocator_v2;
 typedef ::boost::container::container_detail::integral_constant
 <unsigned, boost::container::container_detail::
- version<A>::value> alloc_version;
+ version<Allocator>::value> alloc_version;
 typedef typename allocator_traits_type::
 template portable_rebind_alloc
 <node_type>::type node_allocator_type;
- typedef typename stable_vector_detail::
- select_multiallocation_chain
- < node_allocator_type
- , alloc_version::value
- >::type multiallocation_chain;
+
+ typedef stable_vector_detail::allocator_version_wrapper<node_allocator_type> allocator_version_wrapper_t;
+ typedef typename allocator_version_wrapper_t::multiallocation_chain multiallocation_chain;

 node_ptr allocate_one()
- { return this->allocate_one(alloc_version()); }
+ { return allocator_version_wrapper_t::allocate_one(this->priv_node_alloc()); }

- template<class AllocatorVersion>
- node_ptr allocate_one(AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { return this->priv_node_alloc().allocate(1); }
-
- template<class AllocatorVersion>
- node_ptr allocate_one(AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <!boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { return this->priv_node_alloc().allocate_one(); }
-
- void deallocate_one(node_ptr p)
- { return this->deallocate_one(p, alloc_version()); }
-
- template<class AllocatorVersion>
- void deallocate_one(node_ptr p, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { this->priv_node_alloc().deallocate(p, 1); }
-
- template<class AllocatorVersion>
- void deallocate_one(node_ptr p, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <!boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { this->priv_node_alloc().deallocate_one(p); }
+ void deallocate_one(const node_ptr &p)
+ { allocator_version_wrapper_t::deallocate_one(this->priv_node_alloc(), p); }

 multiallocation_chain allocate_individual(typename allocator_traits_type::size_type n)
- { return this->allocate_individual(n, alloc_version()); }
-
- struct allocate_individual_rollback
- {
- allocate_individual_rollback(stable_vector &sv, multiallocation_chain &chain)
- : mr_sv(sv), mr_chain(chain)
- {}
-
- ~allocate_individual_rollback()
- {
- if(!mr_chain.empty()){
- mr_sv.deallocate_individual(mr_chain);
- }
- }
-
- stable_vector &mr_sv;
- multiallocation_chain &mr_chain;
- };
-
- template<class AllocatorVersion>
- multiallocation_chain allocate_individual
- (typename allocator_traits_type::size_type n, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- {
- multiallocation_chain m;
- multiallocation_chain m_ret;
- allocate_individual_rollback rollback(*this, m);
- while(n--){
- m.push_front(this->allocate_one());
- }
- m.swap(m_ret);
- return ::boost::move(m_ret);
- }
-
- template<class AllocatorVersion>
- multiallocation_chain allocate_individual
- (typename allocator_traits_type::size_type n, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <!boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { return this->priv_node_alloc().allocate_individual(n); }
+ { return allocator_version_wrapper_t::allocate_individual(this->priv_node_alloc(), n); }

 void deallocate_individual(multiallocation_chain &holder)
- { this->deallocate_individual(holder, alloc_version()); }
-
- template<class AllocatorVersion>
- void deallocate_individual(multiallocation_chain & holder, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- {
- while(!holder.empty()){
- this->deallocate_one(holder.pop_front());
- }
- }
-
- template<class AllocatorVersion>
- void deallocate_individual(multiallocation_chain & holder, AllocatorVersion,
- typename boost::container::container_detail::enable_if_c
- <!boost::container::container_detail::is_same<AllocatorVersion, allocator_v1>
- ::value>::type * = 0)
- { this->priv_node_alloc().deallocate_individual(boost::move(holder)); }
+ { allocator_version_wrapper_t::deallocate_individual(this->priv_node_alloc(), holder); }

 friend class stable_vector_detail::clear_on_destroy<stable_vector>;
 typedef stable_vector_detail::iterator
 < T
- , typename allocator_traits<A>::reference
- , typename allocator_traits<A>::pointer> iterator_impl;
+ , typename allocator_traits<Allocator>::reference
+ , typename allocator_traits<Allocator>::pointer> iterator_impl;
 typedef stable_vector_detail::iterator
 < T
- , typename allocator_traits<A>::const_reference
- , typename allocator_traits<A>::const_pointer> const_iterator_impl;
+ , typename allocator_traits<Allocator>::const_reference
+ , typename allocator_traits<Allocator>::const_pointer> const_iterator_impl;
 ///@endcond
 public:

@@ -614,19 +587,19 @@
 // types
 //
 //////////////////////////////////////////////
- typedef T value_type;
- typedef typename ::boost::container::allocator_traits<A>::pointer pointer;
- typedef typename ::boost::container::allocator_traits<A>::const_pointer const_pointer;
- typedef typename ::boost::container::allocator_traits<A>::reference reference;
- typedef typename ::boost::container::allocator_traits<A>::const_reference const_reference;
- typedef typename ::boost::container::allocator_traits<A>::size_type size_type;
- typedef typename ::boost::container::allocator_traits<A>::difference_type difference_type;
- typedef A allocator_type;
- typedef node_allocator_type stored_allocator_type;
- typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
- typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;
+ typedef T value_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef node_allocator_type stored_allocator_type;
+ typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator;
+ typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;

 ///@cond
 private:
@@ -1863,46 +1836,46 @@
 /// @endcond
};

-template <typename T,typename A>
-bool operator==(const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator==(const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
}

-template <typename T,typename A>
-bool operator< (const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator< (const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
}

-template <typename T,typename A>
-bool operator!=(const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator!=(const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return !(x==y);
}

-template <typename T,typename A>
-bool operator> (const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator> (const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return y<x;
}

-template <typename T,typename A>
-bool operator>=(const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator>=(const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return !(x<y);
}

-template <typename T,typename A>
-bool operator<=(const stable_vector<T,A>& x,const stable_vector<T,A>& y)
+template <typename T,typename Allocator>
+bool operator<=(const stable_vector<T,Allocator>& x,const stable_vector<T,Allocator>& y)
{
 return !(x>y);
}

// specialized algorithms:

-template <typename T, typename A>
-void swap(stable_vector<T,A>& x,stable_vector<T,A>& y)
+template <typename T, typename Allocator>
+void swap(stable_vector<T,Allocator>& x,stable_vector<T,Allocator>& y)
{
 x.swap(y);
}

Modified: branches/release/boost/container/string.hpp
==============================================================================
--- branches/release/boost/container/string.hpp (original)
+++ branches/release/boost/container/string.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -84,14 +84,14 @@
// memory. The destructor assumes that the memory either is the internal buffer,
// or else points to a block of memory that was allocated using _String_base's
// allocator and whose size is this->m_storage.
-template <class A>
+template <class Allocator>
class basic_string_base
{
 BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)

- typedef allocator_traits<A> allocator_traits_type;
+ typedef allocator_traits<Allocator> allocator_traits_type;
 public:
- typedef A allocator_type;
+ typedef Allocator allocator_type;
 //! The stored allocator type
 typedef allocator_type stored_allocator_type;
 typedef typename allocator_traits_type::pointer pointer;
@@ -211,24 +211,24 @@
 };

 struct members_holder
- : public A
+ : public Allocator
 {
 members_holder()
- : A()
+ : Allocator()
 {}

 template<class AllocatorConvertible>
 explicit members_holder(BOOST_FWD_REF(AllocatorConvertible) a)
- : A(boost::forward<AllocatorConvertible>(a))
+ : Allocator(boost::forward<AllocatorConvertible>(a))
 {}

 repr_t m_repr;
 } members_;

- const A &alloc() const
+ const Allocator &alloc() const
 { return members_; }

- A &alloc()
+ Allocator &alloc()
 { return members_; }

 static const size_type InternalBufferChars = (sizeof(repr_t) - ShortDataOffset)/sizeof(value_type);
@@ -272,7 +272,7 @@
 typedef container_detail::integral_constant<unsigned, 1> allocator_v1;
 typedef container_detail::integral_constant<unsigned, 2> allocator_v2;
 typedef container_detail::integral_constant<unsigned,
- boost::container::container_detail::version<A>::value> alloc_version;
+ boost::container::container_detail::version<Allocator>::value> alloc_version;

 std::pair<pointer, bool>
 allocation_command(allocation_type command,
@@ -521,22 +521,22 @@
//! In this implementation, iterators are only invalidated by member functions that
//! explicitly change the string's contents.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class CharT, class Traits = std::char_traits<CharT>, class A = std::allocator<CharT> >
+template <class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> >
#else
-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
#endif
class basic_string
- : private container_detail::basic_string_base<A>
+ : private container_detail::basic_string_base<Allocator>
{
 /// @cond
 private:
- typedef allocator_traits<A> allocator_traits_type;
+ typedef allocator_traits<Allocator> allocator_traits_type;
 BOOST_COPYABLE_AND_MOVABLE(basic_string)
- typedef container_detail::basic_string_base<A> base_t;
+ typedef container_detail::basic_string_base<Allocator> base_t;
 static const typename base_t::size_type InternalBufferChars = base_t::InternalBufferChars;

 protected:
- // A helper class to use a char_traits as a function object.
+ // Allocator helper class to use a char_traits as a function object.

 template <class Tr>
 struct Eq_traits
@@ -571,7 +571,7 @@
 public:

 //! The allocator type
- typedef A allocator_type;
+ typedef Allocator allocator_type;
 //! The stored allocator type
 typedef allocator_type stored_allocator_type;
 //! The type of object, CharT, stored in the string
@@ -932,7 +932,7 @@
 //! Complexity: Constant.
 //!
 //! Note: Non-standard extension.
- const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
+ stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
 { return this->alloc(); }

 //! Effects: Returns a reference to the internal allocator.
@@ -942,7 +942,7 @@
 //! Complexity: Constant.
 //!
 //! Note: Non-standard extension.
- stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
+ const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
 { return this->alloc(); }

 //! Effects: Returns the number of the elements contained in the vector.
@@ -1892,7 +1892,7 @@

 //! Requires: The program shall not alter any of the values stored in the character array.
 //!
- //! Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
+ //! Returns: Allocator pointer p such that p + i == &operator[](i) for each i in [0,size()].
 //!
 //! Complexity: constant time.
 const CharT* c_str() const
@@ -1900,7 +1900,7 @@

 //! Requires: The program shall not alter any of the values stored in the character array.
 //!
- //! Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
+ //! Returns: Allocator pointer p such that p + i == &operator[](i) for each i in [0,size()].
 //!
 //! Complexity: constant time.
 const CharT* data() const
@@ -2483,10 +2483,10 @@

/// @cond

-template <class CharT, class Traits, class A>
-const typename basic_string<CharT,Traits,A>::size_type
-basic_string<CharT,Traits,A>::npos
- = (typename basic_string<CharT,Traits,A>::size_type) -1;
+template <class CharT, class Traits, class Allocator>
+const typename basic_string<CharT,Traits,Allocator>::size_type
+basic_string<CharT,Traits,Allocator>::npos
+ = (typename basic_string<CharT,Traits,Allocator>::size_type) -1;

/// @endcond

@@ -2495,273 +2495,212 @@

// Operator+

-template <class CharT, class Traits, class A>
-inline basic_string<CharT,Traits,A>
-operator+(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT,Traits,Allocator>
+ operator+(const basic_string<CharT,Traits,Allocator>& x
+ ,const basic_string<CharT,Traits,Allocator>& y)
{
- typedef basic_string<CharT,Traits,A> str_t;
+ typedef basic_string<CharT,Traits,Allocator> str_t;
 typedef typename str_t::reserve_t reserve_t;
 reserve_t reserve;
 str_t result(reserve, x.size() + y.size(), x.get_stored_allocator());
 result.append(x);
 result.append(y);
- return boost::move(result);
+ return result;
}

-template <class CharT, class Traits, class A> inline
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
- operator+(
- BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
- , BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT, Traits, Allocator> operator+
+ ( BOOST_RV_REF_BEG basic_string<CharT, Traits, Allocator> BOOST_RV_REF_END mx
+ , BOOST_RV_REF_BEG basic_string<CharT, Traits, Allocator> BOOST_RV_REF_END my)
{
 mx += my;
 return boost::move(mx);
}

-template <class CharT, class Traits, class A> inline
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
- operator+(
- BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
- , const basic_string<CharT,Traits,A>& y)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT, Traits, Allocator> operator+
+ ( BOOST_RV_REF_BEG basic_string<CharT, Traits, Allocator> BOOST_RV_REF_END mx
+ , const basic_string<CharT,Traits,Allocator>& y)
{
 mx += y;
 return boost::move(mx);
}

-template <class CharT, class Traits, class A> inline
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
- operator+(const basic_string<CharT,Traits,A>& x,
- BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT, Traits, Allocator> operator+
+ (const basic_string<CharT,Traits,Allocator>& x
+ ,BOOST_RV_REF_BEG basic_string<CharT, Traits, Allocator> BOOST_RV_REF_END my)
{
- typedef typename basic_string<CharT,Traits,A>::size_type size_type;
- my.replace(size_type(0), size_type(0), x);
+ my.insert(my.begin(), x.begin(), x.end());
 return boost::move(my);
}

-template <class CharT, class Traits, class A>
-inline basic_string<CharT,Traits,A>
-operator+(const CharT* s, const basic_string<CharT,Traits,A>& y)
-{
- typedef basic_string<CharT, Traits, A> str_t;
- typedef typename str_t::reserve_t reserve_t;
- reserve_t reserve;
- const typename str_t::size_type n = Traits::length(s);
- str_t result(reserve, n + y.size());
- result.append(s, s + n);
- result.append(y);
- return boost::move(result);
-}
-
-template <class CharT, class Traits, class A> inline
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(const CharT* s,
- BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
-{
- typedef typename basic_string<CharT,Traits,A>::size_type size_type;
- return boost::move(my.replace(size_type(0), size_type(0), s));
-}
-
-template <class CharT, class Traits, class A>
-inline basic_string<CharT,Traits,A>
-operator+(CharT c, const basic_string<CharT,Traits,A>& y)
-{
- typedef basic_string<CharT,Traits,A> str_t;
- typedef typename str_t::reserve_t reserve_t;
- reserve_t reserve;
- str_t result(reserve, 1 + y.size());
- result.push_back(c);
- result.append(y);
- return boost::move(result);
-}
-
-template <class CharT, class Traits, class A> inline
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(CharT c,
- BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT, Traits, Allocator> operator+
+ (const CharT* s, basic_string<CharT, Traits, Allocator> y)
{
- typedef typename basic_string<CharT,Traits,A>::size_type size_type;
- return boost::move(my.replace(size_type(0), size_type(0), &c, &c + 1));
+ y.insert(y.begin(), s, s + Traits::length(s));
+ return y;
}

-template <class CharT, class Traits, class A>
-inline basic_string<CharT,Traits,A>
-operator+(const basic_string<CharT,Traits,A>& x, const CharT* s)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT,Traits,Allocator> operator+
+ (basic_string<CharT,Traits,Allocator> x, const CharT* s)
{
- typedef basic_string<CharT,Traits,A> str_t;
- typedef typename str_t::reserve_t reserve_t;
- reserve_t reserve;
- const typename str_t::size_type n = Traits::length(s);
- str_t result(reserve, x.size() + n, x.get_stored_allocator());
- result.append(x);
- result.append(s, s + n);
- return boost::move(result);
+ x += s;
+ return x;
}

-template <class CharT, class Traits, class A>
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
- , const CharT* s)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT,Traits,Allocator> operator+
+ (CharT c, basic_string<CharT,Traits,Allocator> y)
{
- mx += s;
- return boost::move(mx);
+ y.insert(y.begin(), c);
+ return y;
}

-template <class CharT, class Traits, class A>
-inline basic_string<CharT,Traits,A>
-operator+(const basic_string<CharT,Traits,A>& x, const CharT c)
+template <class CharT, class Traits, class Allocator> inline
+ basic_string<CharT,Traits,Allocator> operator+
+ (basic_string<CharT,Traits,Allocator> x, const CharT c)
{
- typedef basic_string<CharT,Traits,A> str_t;
- typedef typename str_t::reserve_t reserve_t;
- reserve_t reserve;
- str_t result(reserve, x.size() + 1, x.get_stored_allocator());
- result.append(x);
- result.push_back(c);
- return boost::move(result);
-}
-
-template <class CharT, class Traits, class A>
-BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+( BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
- , const CharT c)
-{
- mx += c;
- return boost::move(mx);
+ x += c;
+ return x;
}

// Operator== and operator!=

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator==(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y)
+operator==(const basic_string<CharT,Traits,Allocator>& x,
+ const basic_string<CharT,Traits,Allocator>& y)
{
 return x.size() == y.size() &&
 Traits::compare(x.data(), y.data(), x.size()) == 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator==(const CharT* s, const basic_string<CharT,Traits,A>& y)
+operator==(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
{
- typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
+ typename basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
 return n == y.size() && Traits::compare(s, y.data(), n) == 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator==(const basic_string<CharT,Traits,A>& x, const CharT* s)
+operator==(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
{
- typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
+ typename basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
 return x.size() == n && Traits::compare(x.data(), s, n) == 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator!=(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y)
+operator!=(const basic_string<CharT,Traits,Allocator>& x,
+ const basic_string<CharT,Traits,Allocator>& y)
 { return !(x == y); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator!=(const CharT* s, const basic_string<CharT,Traits,A>& y)
+operator!=(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
 { return !(s == y); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator!=(const basic_string<CharT,Traits,A>& x, const CharT* s)
+operator!=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 { return !(x == s); }

// Operator< (and also >, <=, and >=).

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<(const basic_string<CharT,Traits,A>& x, const basic_string<CharT,Traits,A>& y)
+operator<(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y)
{
 return x.compare(y) < 0;
-// return basic_string<CharT,Traits,A>
+// return basic_string<CharT,Traits,Allocator>
// ::s_compare(x.begin(), x.end(), y.begin(), y.end()) < 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<(const CharT* s, const basic_string<CharT,Traits,A>& y)
+operator<(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
{
 return y.compare(s) > 0;
-// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
-// return basic_string<CharT,Traits,A>
+// basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
+// return basic_string<CharT,Traits,Allocator>
// ::s_compare(s, s + n, y.begin(), y.end()) < 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<(const basic_string<CharT,Traits,A>& x,
+operator<(const basic_string<CharT,Traits,Allocator>& x,
 const CharT* s)
{
 return x.compare(s) < 0;
-// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
-// return basic_string<CharT,Traits,A>
+// basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
+// return basic_string<CharT,Traits,Allocator>
// ::s_compare(x.begin(), x.end(), s, s + n) < 0;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y) {
+operator>(const basic_string<CharT,Traits,Allocator>& x,
+ const basic_string<CharT,Traits,Allocator>& y) {
 return y < x;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>(const CharT* s, const basic_string<CharT,Traits,A>& y) {
+operator>(const CharT* s, const basic_string<CharT,Traits,Allocator>& y) {
 return y < s;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>(const basic_string<CharT,Traits,A>& x, const CharT* s)
+operator>(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
{
 return s < x;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<=(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y)
+operator<=(const basic_string<CharT,Traits,Allocator>& x,
+ const basic_string<CharT,Traits,Allocator>& y)
{
 return !(y < x);
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<=(const CharT* s, const basic_string<CharT,Traits,A>& y)
+operator<=(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
 { return !(y < s); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator<=(const basic_string<CharT,Traits,A>& x, const CharT* s)
+operator<=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 { return !(s < x); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>=(const basic_string<CharT,Traits,A>& x,
- const basic_string<CharT,Traits,A>& y)
+operator>=(const basic_string<CharT,Traits,Allocator>& x,
+ const basic_string<CharT,Traits,Allocator>& y)
 { return !(x < y); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>=(const CharT* s, const basic_string<CharT,Traits,A>& y)
+operator>=(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
 { return !(s < y); }

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline bool
-operator>=(const basic_string<CharT,Traits,A>& x, const CharT* s)
+operator>=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 { return !(x < s); }

// Swap.
-template <class CharT, class Traits, class A>
-inline void swap(basic_string<CharT,Traits,A>& x, basic_string<CharT,Traits,A>& y)
+template <class CharT, class Traits, class Allocator>
+inline void swap(basic_string<CharT,Traits,Allocator>& x, basic_string<CharT,Traits,Allocator>& y)
{ x.swap(y); }

/// @cond
@@ -2786,17 +2725,17 @@
} //namespace container_detail {
/// @endcond

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const basic_string<CharT,Traits,A>& s)
+operator<<(std::basic_ostream<CharT, Traits>& os, const basic_string<CharT,Traits,Allocator>& s)
{
 typename std::basic_ostream<CharT, Traits>::sentry sentry(os);
 bool ok = false;

 if (sentry) {
 ok = true;
- typename basic_string<CharT,Traits,A>::size_type n = s.size();
- typename basic_string<CharT,Traits,A>::size_type pad_len = 0;
+ typename basic_string<CharT,Traits,Allocator>::size_type n = s.size();
+ typename basic_string<CharT,Traits,Allocator>::size_type pad_len = 0;
 const bool left = (os.flags() & std::ios::left) != 0;
 const std::size_t w = os.width(0);
 std::basic_streambuf<CharT, Traits>* buf = os.rdbuf();
@@ -2821,9 +2760,9 @@
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
std::basic_istream<CharT, Traits>&
-operator>>(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,A>& s)
+operator>>(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,Allocator>& s)
{
 typename std::basic_istream<CharT, Traits>::sentry sentry(is);

@@ -2868,11 +2807,11 @@
 return is;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
std::basic_istream<CharT, Traits>&
-getline(std::istream& is, basic_string<CharT,Traits,A>& s,CharT delim)
+getline(std::istream& is, basic_string<CharT,Traits,Allocator>& s,CharT delim)
{
- typename basic_string<CharT,Traits,A>::size_type nread = 0;
+ typename basic_string<CharT,Traits,Allocator>::size_type nread = 0;
 typename std::basic_istream<CharT, Traits>::sentry sentry(is, true);
 if (sentry) {
 std::basic_streambuf<CharT, Traits>* buf = is.rdbuf();
@@ -2900,15 +2839,15 @@
 return is;
}

-template <class CharT, class Traits, class A>
+template <class CharT, class Traits, class Allocator>
inline std::basic_istream<CharT, Traits>&
-getline(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,A>& s)
+getline(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,Allocator>& s)
{
 return getline(is, s, '\n');
}

-template <class Ch, class A>
-inline std::size_t hash_value(basic_string<Ch, std::char_traits<Ch>, A> const& v)
+template <class Ch, class Allocator>
+inline std::size_t hash_value(basic_string<Ch, std::char_traits<Ch>, Allocator> const& v)
{
 return hash_range(v.begin(), v.end());
}
@@ -2921,10 +2860,10 @@
/*
//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class C, class T, class A>
-struct has_trivial_destructor_after_move<boost::container::basic_string<C, T, A> >
+template <class C, class T, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::basic_string<C, T, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value;
};
*/
}

Modified: branches/release/boost/container/vector.hpp
==============================================================================
--- branches/release/boost/container/vector.hpp (original)
+++ branches/release/boost/container/vector.hpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -207,11 +207,11 @@
 { return static_cast<const vector_const_iterator<Pointer>&>(*this) - right; }
};

-template <class T, class A>
+template <class T, class Allocator>
struct vector_value_traits
{
 typedef T value_type;
- typedef A allocator_type;
+ typedef Allocator allocator_type;
 static const bool trivial_dctr = boost::has_trivial_destructor<value_type>::value;
 static const bool trivial_dctr_after_move = trivial_dctr;
 //::boost::has_trivial_destructor_after_move<value_type>::value || trivial_dctr;
@@ -229,37 +229,37 @@
 //to deallocate values already constructed
 typedef typename container_detail::if_c
 <trivial_dctr
- ,container_detail::null_scoped_destructor_n<A>
- ,container_detail::scoped_destructor_n<A>
+ ,container_detail::null_scoped_destructor_n<Allocator>
+ ,container_detail::scoped_destructor_n<Allocator>
>::type OldArrayDestructor;
 //This is the anti-exception array destructor
 //to destroy objects created with copy construction
 typedef typename container_detail::if_c
 <nothrow_copy
- ,container_detail::null_scoped_destructor_n<A>
- ,container_detail::scoped_destructor_n<A>
+ ,container_detail::null_scoped_destructor_n<Allocator>
+ ,container_detail::scoped_destructor_n<Allocator>
>::type ArrayDestructor;
 //This is the anti-exception array deallocator
 typedef typename container_detail::if_c
 <nothrow_copy
- ,container_detail::null_scoped_array_deallocator<A>
- ,container_detail::scoped_array_deallocator<A>
+ ,container_detail::null_scoped_array_deallocator<Allocator>
+ ,container_detail::scoped_array_deallocator<Allocator>
>::type ArrayDeallocator;
};

//!This struct deallocates and allocated memory
-template <class A>
+template <class Allocator>
struct vector_alloc_holder
{
- typedef boost::container::allocator_traits<A> allocator_traits_type;
+ typedef boost::container::allocator_traits<Allocator> allocator_traits_type;
 typedef typename allocator_traits_type::pointer pointer;
 typedef typename allocator_traits_type::size_type size_type;
 typedef typename allocator_traits_type::value_type value_type;
- typedef vector_value_traits<value_type, A> value_traits;
+ typedef vector_value_traits<value_type, Allocator> value_traits;

 //Constructor, does not throw
 vector_alloc_holder()
- BOOST_CONTAINER_NOEXCEPT_IF(::boost::has_nothrow_default_constructor<A>::value)
+ BOOST_CONTAINER_NOEXCEPT_IF(::boost::has_nothrow_default_constructor<Allocator>::value)
 : members_()
 {}

@@ -279,7 +279,7 @@
 typedef container_detail::integral_constant<unsigned, 1> allocator_v1;
 typedef container_detail::integral_constant<unsigned, 2> allocator_v2;
 typedef container_detail::integral_constant<unsigned,
- boost::container::container_detail::version<A>::value> alloc_version;
+ boost::container::container_detail::version<Allocator>::value> alloc_version;
 std::pair<pointer, bool>
 allocation_command(allocation_type command,
 size_type limit_size,
@@ -325,7 +325,7 @@
 }

 struct members_holder
- : public A
+ : public Allocator
 {
 private:
 members_holder(const members_holder&);
@@ -333,11 +333,11 @@
 public:
 template<class Alloc>
 explicit members_holder(BOOST_FWD_REF(Alloc) alloc)
- : A(boost::forward<Alloc>(alloc)), m_start(0), m_size(0), m_capacity(0)
+ : Allocator(boost::forward<Alloc>(alloc)), m_start(0), m_size(0), m_capacity(0)
 {}

 members_holder()
- : A(), m_start(0), m_size(0), m_capacity(0)
+ : Allocator(), m_start(0), m_size(0), m_capacity(0)
 {}

 pointer m_start;
@@ -352,10 +352,10 @@
 container_detail::do_swap(this->members_.m_capacity, x.members_.m_capacity);
 }

- A &alloc()
+ Allocator &alloc()
 { return members_; }

- const A &alloc() const
+ const Allocator &alloc() const
 { return members_; }

 protected:
@@ -401,15 +401,15 @@
//! boost::container::vector is similar to std::vector but it's compatible
//! with shared memory and memory mapped files.
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class A = std::allocator<T> >
+template <class T, class Allocator = std::allocator<T> >
#else
-template <class T, class A>
+template <class T, class Allocator>
#endif
-class vector : private container_detail::vector_alloc_holder<A>
+class vector : private container_detail::vector_alloc_holder<Allocator>
{
 /// @cond
- typedef container_detail::vector_alloc_holder<A> base_t;
- typedef allocator_traits<A> allocator_traits_type;
+ typedef container_detail::vector_alloc_holder<Allocator> base_t;
+ typedef allocator_traits<Allocator> allocator_traits_type;
 /// @endcond
 public:
 //////////////////////////////////////////////
@@ -418,25 +418,25 @@
 //
 //////////////////////////////////////////////

- typedef T value_type;
- typedef typename ::boost::container::allocator_traits<A>::pointer pointer;
- typedef typename ::boost::container::allocator_traits<A>::const_pointer const_pointer;
- typedef typename ::boost::container::allocator_traits<A>::reference reference;
- typedef typename ::boost::container::allocator_traits<A>::const_reference const_reference;
- typedef typename ::boost::container::allocator_traits<A>::size_type size_type;
- typedef typename ::boost::container::allocator_traits<A>::difference_type difference_type;
- typedef A allocator_type;
- typedef allocator_type stored_allocator_type;
- 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(std::reverse_iterator<iterator>) reverse_iterator;
- typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;
+ typedef T value_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
+ typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
+ typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
+ typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
+ typedef Allocator allocator_type;
+ typedef Allocator stored_allocator_type;
+ 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(std::reverse_iterator<iterator>) reverse_iterator;
+ typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_iterator;

 /// @cond
 private:
 BOOST_COPYABLE_AND_MOVABLE(vector)
 typedef container_detail::advanced_insert_aux_int<T*> advanced_insert_aux_int_t;
- typedef container_detail::vector_value_traits<value_type, A> value_traits;
+ typedef container_detail::vector_value_traits<value_type, Allocator> value_traits;

 typedef typename base_t::allocator_v1 allocator_v1;
 typedef typename base_t::allocator_v2 allocator_v2;
@@ -460,7 +460,7 @@
 //!
 //! Complexity: Constant.
 vector()
- BOOST_CONTAINER_NOEXCEPT_IF(::boost::has_nothrow_default_constructor<A>::value)
+ BOOST_CONTAINER_NOEXCEPT_IF(::boost::has_nothrow_default_constructor<Allocator>::value)
 : base_t()
 {}

@@ -469,7 +469,7 @@
 //! Throws: Nothing
 //!
 //! Complexity: Constant.
- explicit vector(const A& a) BOOST_CONTAINER_NOEXCEPT
+ explicit vector(const Allocator& a) BOOST_CONTAINER_NOEXCEPT
 : base_t(a)
 {}

@@ -683,6 +683,7 @@
 allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
 { return this->alloc(); }

+
 //! Effects: Returns a reference to the internal allocator.
 //!
 //! Throws: Nothing
@@ -690,7 +691,7 @@
 //! Complexity: Constant.
 //!
 //! Note: Non-standard extension.
- const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
+ stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
 { return this->alloc(); }

 //! Effects: Returns a reference to the internal allocator.
@@ -700,7 +701,7 @@
 //! Complexity: Constant.
 //!
 //! Note: Non-standard extension.
- stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
+ const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
 { return this->alloc(); }

 //////////////////////////////////////////////
@@ -856,7 +857,7 @@
 else{
 const size_type n = new_size - this->size();
 this->reserve(new_size);
- container_detail::default_construct_aux_proxy<A, T*> proxy(this->alloc(), n);
+ container_detail::default_construct_aux_proxy<Allocator, T*> proxy(this->alloc(), n);
 this->priv_forward_range_insert(this->cend().get_ptr(), n, proxy);
 }
 }
@@ -920,7 +921,7 @@
 else{
 //We will reuse insert code, so create a dummy input iterator
 T *dummy_it(container_detail::to_raw_pointer(this->members_.m_start));
- container_detail::advanced_insert_aux_proxy<A, boost::move_iterator<T*>, T*>
+ container_detail::advanced_insert_aux_proxy<Allocator, boost::move_iterator<T*>, T*>
 proxy(this->alloc(), ::boost::make_move_iterator(dummy_it), ::boost::make_move_iterator(dummy_it));
 //Backwards (and possibly forward) expansion
 if(ret.second){
@@ -957,7 +958,7 @@
 //!
 //! Complexity: Linear to size().
 void shrink_to_fit()
- { priv_shrink_to_fit(alloc_version()); }
+ { this->priv_shrink_to_fit(alloc_version()); }

 //////////////////////////////////////////////
 //
@@ -1059,7 +1060,7 @@
 //
 //////////////////////////////////////////////

- //! Returns: A pointer such that [data(),data() + size()) is a valid range.
+ //! Returns: Allocator pointer such that [data(),data() + size()) is a valid range.
 //! For a non-empty vector, data() == &front().
 //!
 //! Throws: Nothing.
@@ -1068,7 +1069,7 @@
 T* data() BOOST_CONTAINER_NOEXCEPT
 { return container_detail::to_raw_pointer(this->members_.m_start); }

- //! Returns: A pointer such that [data(),data() + size()) is a valid range.
+ //! Returns: Allocator pointer such that [data(),data() + size()) is a valid range.
 //! For a non-empty vector, data() == &front().
 //!
 //! Throws: Nothing.
@@ -1101,7 +1102,7 @@
 ++this->members_.m_size;
 }
 else{
- typedef container_detail::advanced_insert_aux_emplace<A, T*, Args...> type;
+ typedef container_detail::advanced_insert_aux_emplace<Allocator, T*, Args...> type;
 type &&proxy = type(this->alloc(), ::boost::forward<Args>(args)...);
 this->priv_forward_range_insert(back_pos, 1, proxy);
 }
@@ -1122,7 +1123,7 @@
 {
 //Just call more general insert(pos, size, value) and return iterator
 size_type pos_n = position - cbegin();
- typedef container_detail::advanced_insert_aux_emplace<A, T*, Args...> type;
+ typedef container_detail::advanced_insert_aux_emplace<Allocator, T*, Args...> type;
 type &&proxy = type(this->alloc(), ::boost::forward<Args>(args)...);
 this->priv_forward_range_insert(position.get_ptr(), 1, proxy);
 return iterator(this->members_.m_start + pos_n);
@@ -1143,7 +1144,7 @@
 } \
 else{ \
 container_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
- <A, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
+ <Allocator, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
 (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \
 this->priv_forward_range_insert(back_pos, 1, proxy); \
 } \
@@ -1155,7 +1156,7 @@
 { \
 size_type pos_n = pos - cbegin(); \
 container_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
- <A, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
+ <Allocator, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \
 (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \
 this->priv_forward_range_insert(container_detail::to_raw_pointer(pos.get_ptr()), 1,proxy);\
 return iterator(this->members_.m_start + pos_n); \
@@ -1263,7 +1264,7 @@
 {
 const size_type n_pos = pos - this->cbegin();
 const size_type n = std::distance(first, last);
- container_detail::advanced_insert_aux_proxy<A, FwdIt, T*> proxy(this->alloc(), first, last);
+ container_detail::advanced_insert_aux_proxy<Allocator, FwdIt, T*> proxy(this->alloc(), first, last);
 this->priv_forward_range_insert(pos.get_ptr(), n, proxy);
 return this->begin() + n_pos;
 }
@@ -1394,10 +1395,7 @@
 }
 }

- template<class AllocVersion>
- void priv_shrink_to_fit( AllocVersion
- , typename container_detail::enable_if_c<
- container_detail::is_same<AllocVersion, allocator_v1>::value >::type * = 0)
+ void priv_shrink_to_fit(allocator_v1)
 {
 if(this->members_.m_capacity){
 if(!this->size()){
@@ -1412,7 +1410,7 @@
 if(real_cap < this->capacity()){
 //We will reuse insert code, so create a dummy input iterator
 T *dummy_it(container_detail::to_raw_pointer(this->members_.m_start));
- container_detail::advanced_insert_aux_proxy<A, boost::move_iterator<T*>, T*>
+ container_detail::advanced_insert_aux_proxy<Allocator, boost::move_iterator<T*>, T*>
 proxy(this->alloc(), ::boost::make_move_iterator(dummy_it), ::boost::make_move_iterator(dummy_it));
 #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
 ++this->num_alloc;
@@ -1431,10 +1429,7 @@
 }
 }

- template<class AllocVersion>
- void priv_shrink_to_fit(AllocVersion
- , typename container_detail::enable_if_c<
- !container_detail::is_same<AllocVersion, allocator_v1>::value >::type * = 0)
+ void priv_shrink_to_fit(allocator_v2)
 {
 if(this->members_.m_capacity){
 if(!size()){
@@ -1442,7 +1437,7 @@
 }
 else{
 size_type received_size;
- if(this->alloc().allocation_command
+ if(this->allocation_command
 ( shrink_in_place | nothrow_allocation
 , this->capacity(), this->size()
 , received_size, this->members_.m_start).first){
@@ -1535,6 +1530,10 @@
 //Loop for each insertion backwards, first moving the elements after the insertion point,
 //then inserting the element.
 while(insertions_left){
+ if(do_skip){
+ size_type n = *(--last_skip_it);
+ std::advance(last_value_it, -difference_type(n));
+ }
 const size_type pos = static_cast<size_type>(*(--last_position_it));
 BOOST_ASSERT(pos <= old_size_pos);
 //If needed shift the range after the insertion point and the previous insertion point.
@@ -1569,12 +1568,6 @@
 //Insert the new value in the already constructed range
 begin_ptr[pos + insertions_left - 1] = *(--last_value_it);
 }
- if(do_skip){
- size_type n = *(--last_skip_it);
- while(n--){
- --last_value_it;
- }
- }
 --insertions_left;
 hole_size = new_hole_size;
 next_pos = pos;
@@ -1599,7 +1592,7 @@
 //| prefix | range | suffix |raw_mem ~
 //|____________|_______|__________________|_____________~
 //
- //New situation in Case A (hole_size == 0):
+ //New situation in Case Allocator (hole_size == 0):
 // range is moved through move assignments
 //
 // first_pos last_pos limit_pos
@@ -1643,7 +1636,7 @@
 T* const last_ptr = begin_ptr + last_pos;

 size_type hole_size = 0;
- //Case A:
+ //Case Allocator:
 if((last_pos + shift_count) <= limit_pos){
 //All move assigned
 boost::move_backward(first_ptr, last_ptr, last_ptr + shift_count);
@@ -2057,31 +2050,31 @@
 /// @endcond
};

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator==(const vector<T, A>& x, const vector<T, A>& y)
+operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y)
{
 //Check first size and each element if needed
 return x.size() == y.size() && std::equal(x.begin(), x.end(), y.begin());
}

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator!=(const vector<T, A>& x, const vector<T, A>& y)
+operator!=(const vector<T, Allocator>& x, const vector<T, Allocator>& y)
{
 //Check first size and each element if needed
 return x.size() != y.size() || !std::equal(x.begin(), x.end(), y.begin());
}

-template <class T, class A>
+template <class T, class Allocator>
inline bool
-operator<(const vector<T, A>& x, const vector<T, A>& y)
+operator<(const vector<T, Allocator>& x, const vector<T, Allocator>& y)
{
 return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}

-template <class T, class A>
-inline void swap(vector<T, A>& x, vector<T, A>& y)
+template <class T, class Allocator>
+inline void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
{ x.swap(y); }

}}
@@ -2094,10 +2087,10 @@

//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
-template <class T, class A>
-struct has_trivial_destructor_after_move<boost::container::vector<T, A> >
+template <class T, class Allocator>
+struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator> >
{
- static const bool value = has_trivial_destructor<A>::value;
+ static const bool value = has_trivial_destructor<Allocator>::value;
};

*/

Modified: branches/release/libs/container/doc/Jamfile.v2
==============================================================================
--- branches/release/libs/container/doc/Jamfile.v2 (original)
+++ branches/release/libs/container/doc/Jamfile.v2 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -29,12 +29,12 @@
 \"BOOST_CONTAINER_DOXYGEN_INVOKED\" \\
 \"BOOST_CONTAINER_IMPDEF(T)=implementation_defined\" \\
 \"BOOST_CONTAINER_SEEDOC(T)=see_documentation\" \\
+ \"BOOST_CONTAINER_NOEXCEPT=noexcept\" \\
+ \"BOOST_CONTAINER_NOEXCEPT_IF(T)=noexcept(T)\" \\
 \"BOOST_RV_REF(T)=T &&\" \\
 \"BOOST_RV_REF_BEG=\" \\
 \"BOOST_RV_REF_END=&&\" \\
 \"BOOST_COPY_ASSIGN_REF(T)=const T &\" \\
- \"BOOST_RV_REF_2_TEMPL_ARGS(T,a,b)=T<a, b> &&\" \\
- \"BOOST_RV_REF_3_TEMPL_ARGS(T,a,b,c)=T<a,b,c>T<a,b,c> &&\" \\
 \"BOOST_FWD_REF(a)=a &&\""
 <xsl:param>"boost.doxygen.reftitle=Boost.Container Header Reference"
 ;

Modified: branches/release/libs/container/doc/container.qbk
==============================================================================
--- branches/release/libs/container/doc/container.qbk (original)
+++ branches/release/libs/container/doc/container.qbk 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -623,7 +623,8 @@
   [@https://svn.boost.org/trac/boost/ticket/7139 #7139],
   [@https://svn.boost.org/trac/boost/ticket/7215 #7215],
   [@https://svn.boost.org/trac/boost/ticket/7232 #7232],
- [@https://svn.boost.org/trac/boost/ticket/7269 #7269].
+ [@https://svn.boost.org/trac/boost/ticket/7269 #7269],
+ [@https://svn.boost.org/trac/boost/ticket/7439 #7439].
* Implemented LWG Issue #149 (range insertion now returns an iterator) & cleaned up insertion code in most containers
* Corrected aliasing errors.

Modified: branches/release/libs/container/proj/to-do.txt
==============================================================================
--- branches/release/libs/container/proj/to-do.txt (original)
+++ branches/release/libs/container/proj/to-do.txt 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -2,6 +2,9 @@
->Add an example with stateful allocators
->Add test to check convertible types in push_back/insert
->Add SCARY iterators.
+->Align with C++11 [multi]map::insert(P &&p) overload.
+->Unify all allocator version traits in one class (starting from stable_vector_detail::allocator_version_wrapper)
+ maybe in allocator_traits?

Review allocator traits
@@ -53,22 +56,10 @@

Add std:: hashing support

-Take out from class definition iterators in slist & list
-
Fix trivial destructor after move and other optimizing traits

-Define typedefs exactly like the standard to generate better documentation. for implementation defined types:
- #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
- #define BOOST_CONTAINER_IMPLDEF(TYPE) TYPE
- #else
- #define BOOST_CONTAINER_IMPLDEF(TYPE) implementation_defined
- #endif
Mark previous() in slist/and forward_list as non-standard

-Replace all insert_const_ref_type with BOOST_MOVE_CONVERSION_AWARE_CATCH_XXX
-
-
-
Function order:

----------type------------

Modified: branches/release/libs/container/test/string_test.cpp
==============================================================================
--- branches/release/libs/container/test/string_test.cpp (original)
+++ branches/release/libs/container/test/string_test.cpp 2012-10-01 07:32:04 EDT (Mon, 01 Oct 2012)
@@ -85,7 +85,8 @@
 { return "Suffix"; }
 static const char *LongString()
 { return "LongLongLongLongLongLongLongLongLongLongLongLongLongString"; }
-
+ static char Char()
+ { return 'C'; }
 static void sprintf_number(char *buf, int number)
 {
 std::sprintf(buf, "%i", number);
@@ -103,7 +104,8 @@
 { return L"Suffix"; }
 static const wchar_t *LongString()
 { return L"LongLongLongLongLongLongLongLongLongLongLongLongLongString"; }
-
+ static wchar_t Char()
+ { return L'C'; }
 static void sprintf_number(wchar_t *buffer, unsigned int number)
 {
 //For compilers without wsprintf, print it backwards
@@ -398,6 +400,22 @@
 if(!StringEqual()(bs4, ss4)){
 return 1;
 }
+
+ bs2 = string_literals<CharType>::String();
+ ss2 = string_literals<CharType>::String();
+ bs4 = string_literals<CharType>::Char() + bs2;
+ ss4 = string_literals<CharType>::Char() + ss2;
+ if(!StringEqual()(bs4, ss4)){
+ return 1;
+ }
+
+ bs2 = string_literals<CharType>::String();
+ ss2 = string_literals<CharType>::String();
+ bs4 = bs2 + string_literals<CharType>::Char();
+ ss4 = ss2 + string_literals<CharType>::Char();
+ if(!StringEqual()(bs4, ss4)){
+ return 1;
+ }
 }

 //When done, delete vector

Next message: matias.capeletto_at_[hidden]: "[Boost-commit] svn:boost r80807 - in trunk/boost/bimap: . detail relation"
Previous message: eric_at_[hidden]: "[Boost-commit] svn:boost r80805 - in branches/release: . libs libs/phoenix/test/algorithm"

Date view	Thread view	Subject view	Author view

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