Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r62270 - in sandbox/move/libs/container/doc/html: . boost/container
From: igaztanaga_at_[hidden]
Date: 2010-05-27 13:05:33

Next message: jewillco_at_[hidden]: "[Boost-commit] svn:boost r62271 - trunk/boost/graph/distributed"
Previous message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r62269 - sandbox/move/libs/container/doc/html/images"

Author: igaztanaga
Date: 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
New Revision: 62270
URL: http://svn.boost.org/trac/boost/changeset/62270

Log:
Added container documentation
Text files modified:
   sandbox/move/libs/container/doc/html/boost/container/basic_string.html | 452 ++++++++++++++++++++--------------------
   sandbox/move/libs/container/doc/html/boost/container/deque.html | 231 ++++++++++----------
   sandbox/move/libs/container/doc/html/boost/container/flat_map.html | 242 ++++++++++----------
   sandbox/move/libs/container/doc/html/boost/container/flat_multimap.html | 208 +++++++++---------
   sandbox/move/libs/container/doc/html/boost/container/flat_multiset.html | 215 +++++++++---------
   sandbox/move/libs/container/doc/html/boost/container/flat_set.html | 215 +++++++++---------
   sandbox/move/libs/container/doc/html/boost/container/list.html | 272 ++++++++++++------------
   sandbox/move/libs/container/doc/html/boost/container/map.html | 232 ++++++++++----------
   sandbox/move/libs/container/doc/html/boost/container/multimap.html | 204 ++++++++---------
   sandbox/move/libs/container/doc/html/boost/container/multiset.html | 202 ++++++++--------
   sandbox/move/libs/container/doc/html/boost/container/ordered_range.html | 8
   sandbox/move/libs/container/doc/html/boost/container/ordered_range_impl_t.html | 8
   sandbox/move/libs/container/doc/html/boost/container/ordered_unique_range.html | 2
   sandbox/move/libs/container/doc/html/boost/container/set.html | 202 ++++++++--------
   sandbox/move/libs/container/doc/html/boost/container/slist.html | 285 ++++++++++++------------
   sandbox/move/libs/container/doc/html/boost/container/stable_vector.html | 218 +++++++++---------
   sandbox/move/libs/container/doc/html/boost/container/string.html | 2
   sandbox/move/libs/container/doc/html/boost/container/vector.html | 240 ++++++++++----------
   sandbox/move/libs/container/doc/html/boost/container/wstring.html | 2
   sandbox/move/libs/container/doc/html/boost_container_reference.html | 264 +++++++++++-----------
   sandbox/move/libs/container/doc/html/index.html | 4
   21 files changed, 1848 insertions(+), 1860 deletions(-)

Modified: sandbox/move/libs/container/doc/html/boost/container/basic_string.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/basic_string.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/basic_string.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -51,131 +51,131 @@
 typedef std::reverse_iterator< const_iterator > <a name="boost.container.basic_string.const_reverse_iterator"></a>const_reverse_iterator; // Const iterator used to iterate backwards through a string. 

 // construct/copy/destruct
- basic_string(reserve_t, std::size_t,
+ basic_string(reserve_t, std::size_t,
 const allocator_type & = allocator_type());
- basic_string(const allocator_type & = allocator_type());
- basic_string(const basic_string &);
- basic_string(BOOST_MOVE_MACRO_RV_REF(basic_string));
- basic_string(const basic_string &, size_type, size_type = npos,
+ basic_string(const allocator_type & = allocator_type());
+ basic_string(const basic_string &);
+ basic_string(basic_string &&);
+ basic_string(const basic_string &, size_type, size_type = npos,
 const allocator_type & = allocator_type());
- basic_string(const CharT *, size_type,
+ basic_string(const CharT *, size_type,
 const allocator_type & = allocator_type());
- basic_string(const CharT *, const allocator_type & = allocator_type());
- basic_string(size_type, CharT, const allocator_type & = allocator_type());
+ basic_string(const CharT *, const allocator_type & = allocator_type());
+ basic_string(size_type, CharT, const allocator_type & = allocator_type());
 template<typename InputIterator>
- basic_string(InputIterator, InputIterator,
+ basic_string(InputIterator, InputIterator,
 const allocator_type & = allocator_type());
- basic_string& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(basic_string));
- basic_string& operator=(BOOST_MOVE_MACRO_RV_REF(basic_string));
- basic_string& operator=(const CharT *);
- basic_string& operator=(CharT);
- ~basic_string();
+ basic_string& operator=(const basic_string &);
+ basic_string& operator=(basic_string &&);
+ basic_string& operator=(const CharT *);
+ basic_string& operator=(CharT);
+ ~basic_string();

- // public member functions
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- allocator_type get_allocator() const;
- size_type size() const;
- size_type length() const;
- size_type max_size() const;
- void resize(size_type, CharT) ;
- void resize(size_type) ;
- void reserve(size_type) ;
- size_type capacity() const;
- void clear() ;
- bool empty() const;
- reference operator[](size_type) ;
- const_reference operator[](size_type) const;
- reference at(size_type) ;
- const_reference at(size_type) const;
- basic_string & operator+=(const basic_string &) ;
- basic_string & operator+=(const CharT *) ;
- basic_string & operator+=(CharT) ;
- basic_string & append(const basic_string &) ;
- basic_string & append(const basic_string &, size_type, size_type) ;
- basic_string & append(const CharT *, size_type) ;
- basic_string & append(const CharT *) ;
- basic_string & append(size_type, CharT) ;
- template<typename InputIter> basic_string & append(InputIter, InputIter) ;
- void push_back(CharT) ;
- void pop_back() ;
- basic_string & assign(const basic_string &) ;
- basic_string & assign(BOOST_MOVE_MACRO_RV_REF(basic_string)) ;
- basic_string & assign(const basic_string &, size_type, size_type) ;
- basic_string & assign(const CharT *, size_type) ;
- basic_string & assign(const CharT *) ;
- basic_string & assign(size_type, CharT) ;
- template<typename InputIter> basic_string & assign(InputIter, InputIter) ;
- basic_string & assign(const CharT *, const CharT *) ;
- basic_string & insert(size_type, const basic_string &) ;
+ // public member functions
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ allocator_type get_allocator() const;
+ size_type size() const;
+ size_type length() const;
+ size_type max_size() const;
+ void resize(size_type, CharT) ;
+ void resize(size_type) ;
+ void reserve(size_type) ;
+ size_type capacity() const;
+ void clear() ;
+ bool empty() const;
+ reference operator[](size_type) ;
+ const_reference operator[](size_type) const;
+ reference at(size_type) ;
+ const_reference at(size_type) const;
+ basic_string & operator+=(const basic_string &) ;
+ basic_string & operator+=(const CharT *) ;
+ basic_string & operator+=(CharT) ;
+ basic_string & append(const basic_string &) ;
+ basic_string & append(const basic_string &, size_type, size_type) ;
+ basic_string & append(const CharT *, size_type) ;
+ basic_string & append(const CharT *) ;
+ basic_string & append(size_type, CharT) ;
+ template<typename InputIter> basic_string & append(InputIter, InputIter) ;
+ void push_back(CharT) ;
+ void pop_back() ;
+ basic_string & assign(const basic_string &) ;
+ basic_string & assign(basic_string &&) ;
+ basic_string & assign(const basic_string &, size_type, size_type) ;
+ basic_string & assign(const CharT *, size_type) ;
+ basic_string & assign(const CharT *) ;
+ basic_string & assign(size_type, CharT) ;
+ template<typename InputIter> basic_string & assign(InputIter, InputIter) ;
+ basic_string & assign(const CharT *, const CharT *) ;
+ basic_string & insert(size_type, const basic_string &) ;
 basic_string &
- insert(size_type, const basic_string &, size_type, size_type) ;
- basic_string & insert(size_type, const CharT *, size_type) ;
- basic_string & insert(size_type, const CharT *) ;
- basic_string & insert(size_type, size_type, CharT) ;
- iterator insert(iterator, CharT) ;
- void insert(iterator, std::size_t, CharT) ;
- template<typename InputIter> void insert(iterator, InputIter, InputIter) ;
- basic_string & erase(size_type = 0, size_type = npos) ;
- iterator erase(iterator) ;
- iterator erase(iterator, iterator) ;
- basic_string & replace(size_type, size_type, const basic_string &) ;
+ insert(size_type, const basic_string &, size_type, size_type) ;
+ basic_string & insert(size_type, const CharT *, size_type) ;
+ basic_string & insert(size_type, const CharT *) ;
+ basic_string & insert(size_type, size_type, CharT) ;
+ iterator insert(iterator, CharT) ;
+ void insert(iterator, std::size_t, CharT) ;
+ template<typename InputIter> void insert(iterator, InputIter, InputIter) ;
+ basic_string & erase(size_type = 0, size_type = npos) ;
+ iterator erase(iterator) ;
+ iterator erase(iterator, iterator) ;
+ basic_string & replace(size_type, size_type, const basic_string &) ;
 basic_string &
- replace(size_type, size_type, const basic_string &, size_type, size_type) ;
- basic_string & replace(size_type, size_type, const CharT *, size_type) ;
- basic_string & replace(size_type, size_type, const CharT *) ;
- basic_string & replace(size_type, size_type, size_type, CharT) ;
- basic_string & replace(iterator, iterator, const basic_string &) ;
- basic_string & replace(iterator, iterator, const CharT *, size_type) ;
- basic_string & replace(iterator, iterator, const CharT *) ;
- basic_string & replace(iterator, iterator, size_type, CharT) ;
+ replace(size_type, size_type, const basic_string &, size_type, size_type) ;
+ basic_string & replace(size_type, size_type, const CharT *, size_type) ;
+ basic_string & replace(size_type, size_type, const CharT *) ;
+ basic_string & replace(size_type, size_type, size_type, CharT) ;
+ basic_string & replace(iterator, iterator, const basic_string &) ;
+ basic_string & replace(iterator, iterator, const CharT *, size_type) ;
+ basic_string & replace(iterator, iterator, const CharT *) ;
+ basic_string & replace(iterator, iterator, size_type, CharT) ;
 template<typename InputIter>
- basic_string & replace(iterator, iterator, InputIter, InputIter) ;
- size_type copy(CharT *, size_type, size_type = 0) const;
- void swap(basic_string &) ;
- const CharT * c_str() const;
- const CharT * data() const;
- size_type find(const basic_string &, size_type = 0) const;
- size_type find(const CharT *, size_type = 0) const;
- size_type find(const CharT *, size_type, size_type) const;
- size_type find(CharT, size_type = 0) const;
- size_type rfind(const basic_string &, size_type = npos) const;
- size_type rfind(const CharT *, size_type = npos) const;
- size_type rfind(const CharT *, size_type, size_type) const;
- size_type rfind(CharT, size_type = npos) const;
- size_type find_first_of(const basic_string &, size_type = 0) const;
- size_type find_first_of(const CharT *, size_type = 0) const;
- size_type find_first_of(const CharT *, size_type, size_type) const;
- size_type find_first_of(CharT, size_type = 0) const;
- size_type find_last_of(const basic_string &, size_type = npos) const;
- size_type find_last_of(const CharT *, size_type = npos) const;
- size_type find_last_of(const CharT *, size_type, size_type) const;
- size_type find_last_of(CharT, size_type = npos) const;
- size_type find_first_not_of(const basic_string &, size_type = 0) const;
- size_type find_first_not_of(const CharT *, size_type = 0) const;
- size_type find_first_not_of(const CharT *, size_type, size_type) const;
- size_type find_first_not_of(CharT, size_type = 0) const;
- size_type find_last_not_of(const basic_string &, size_type = npos) const;
- size_type find_last_not_of(const CharT *, size_type = npos) const;
- size_type find_last_not_of(const CharT *, size_type, size_type) const;
- size_type find_last_not_of(CharT, size_type = npos) const;
- basic_string substr(size_type = 0, size_type = npos) const;
- int compare(const basic_string &) const;
- int compare(size_type, size_type, const basic_string &) const;
- int compare(size_type, size_type, const basic_string &, size_type,
+ basic_string & replace(iterator, iterator, InputIter, InputIter) ;
+ size_type copy(CharT *, size_type, size_type = 0) const;
+ void swap(basic_string &) ;
+ const CharT * c_str() const;
+ const CharT * data() const;
+ size_type find(const basic_string &, size_type = 0) const;
+ size_type find(const CharT *, size_type = 0) const;
+ size_type find(const CharT *, size_type, size_type) const;
+ size_type find(CharT, size_type = 0) const;
+ size_type rfind(const basic_string &, size_type = npos) const;
+ size_type rfind(const CharT *, size_type = npos) const;
+ size_type rfind(const CharT *, size_type, size_type) const;
+ size_type rfind(CharT, size_type = npos) const;
+ size_type find_first_of(const basic_string &, size_type = 0) const;
+ size_type find_first_of(const CharT *, size_type = 0) const;
+ size_type find_first_of(const CharT *, size_type, size_type) const;
+ size_type find_first_of(CharT, size_type = 0) const;
+ size_type find_last_of(const basic_string &, size_type = npos) const;
+ size_type find_last_of(const CharT *, size_type = npos) const;
+ size_type find_last_of(const CharT *, size_type, size_type) const;
+ size_type find_last_of(CharT, size_type = npos) const;
+ size_type find_first_not_of(const basic_string &, size_type = 0) const;
+ size_type find_first_not_of(const CharT *, size_type = 0) const;
+ size_type find_first_not_of(const CharT *, size_type, size_type) const;
+ size_type find_first_not_of(CharT, size_type = 0) const;
+ size_type find_last_not_of(const basic_string &, size_type = npos) const;
+ size_type find_last_not_of(const CharT *, size_type = npos) const;
+ size_type find_last_not_of(const CharT *, size_type, size_type) const;
+ size_type find_last_not_of(CharT, size_type = npos) const;
+ basic_string substr(size_type = 0, size_type = npos) const;
+ int compare(const basic_string &) const;
+ int compare(size_type, size_type, const basic_string &) const;
+ int compare(size_type, size_type, const basic_string &, size_type,
 size_type) const;
- int compare(const CharT *) const;
- int compare(size_type, size_type, const CharT *, size_type = npos) const;
+ int compare(const CharT *) const;
+ int compare(size_type, size_type, const CharT *, size_type = npos) const;
 static const size_type npos; // The largest possible value of type size_type. That is, size_type(-1). 
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id547679"></a><h2>Description</h2>
+<a name="id531627"></a><h2>Description</h2>
The basic_string class represents a Sequence of characters. It contains all the usual operations of a Sequence, and, additionally, it contains standard string operations such as search and concatenation.
The basic_string class is parameterized by character type, and by that type's Character Traits.
This class has performance characteristics very much like vector<>, meaning, for example, that it does not perform reference-count or copy-on-write, and that concatenation of two strings is an O(N) operation.
@@ -183,7 +183,7 @@
Note that the C++ standard does not specify the complexity of basic_string operations. In this implementation, basic_string has performance characteristics very similar to those of vector: access to a single character is O(1), while copy and concatenation are O(N).
In this implementation, begin(), end(), rbegin(), rend(), operator[], c_str(), and data() do not invalidate iterators. In this implementation, iterators are only invalidated by member functions that explicitly change the string's contents. 
<div class="refsect2" lang="en">
-<a name="id547697"></a><h3>
+<a name="id531645"></a><h3>
<a name="boost.container.basic_stringtypes"></a><code class="computeroutput">basic_string</code>
 public
 types</h3>
@@ -194,75 +194,75 @@
</li></ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id547724"></a><h3>
+<a name="id531673"></a><h3>
<a name="boost.container.basic_stringconstruct-copy-destruct"></a><code class="computeroutput">basic_string</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
-<li><pre class="literallayout"><a name="id326049-bb"></a>basic_string(reserve_t, std::size_t n,
+<li><pre class="literallayout"><a name="id326030-bb"></a>basic_string(reserve_t, std::size_t n,
 const allocator_type & a = allocator_type());</pre></li>
<li>
-<pre class="literallayout"><a name="id326067-bb"></a>basic_string(const allocator_type & a = allocator_type());</pre>
+<pre class="literallayout"><a name="id326048-bb"></a>basic_string(const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter.
Throws: If allocator_type's copy constructor throws. 
</li>
<li>
-<pre class="literallayout"><a name="id326090-bb"></a>basic_string(const basic_string & s);</pre>
+<pre class="literallayout"><a name="id326071-bb"></a>basic_string(const basic_string & s);</pre>
Effects: Copy constructs a basic_string.
Postcondition: x == *this.
Throws: If allocator_type's default constructor or copy constructor throws. 
</li>
<li>
-<pre class="literallayout"><a name="id326118-bb"></a>basic_string(BOOST_MOVE_MACRO_RV_REF(basic_string) s);</pre>
+<pre class="literallayout"><a name="id326100-bb"></a>basic_string(basic_string && s);</pre>
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout"><a name="id326147-bb"></a>basic_string(const basic_string & s, size_type pos, size_type n = npos,
+<pre class="literallayout"><a name="id326128-bb"></a>basic_string(const basic_string & s, size_type pos, size_type n = npos,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by a specific number of characters of the s string. 
</li>
<li>
-<pre class="literallayout"><a name="id326183-bb"></a>basic_string(const CharT * s, size_type n,
+<pre class="literallayout"><a name="id326164-bb"></a>basic_string(const CharT * s, size_type n,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by a specific number of characters of the s c-string. 
</li>
<li>
-<pre class="literallayout"><a name="id326208-bb"></a>basic_string(const CharT * s, const allocator_type & a = allocator_type());</pre>
+<pre class="literallayout"><a name="id326189-bb"></a>basic_string(const CharT * s, const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by the null-terminated s c-string. 
</li>
<li>
-<pre class="literallayout"><a name="id326229-bb"></a>basic_string(size_type n, CharT c,
+<pre class="literallayout"><a name="id326209-bb"></a>basic_string(size_type n, CharT c,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by n copies of c. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id326254-bb"></a>basic_string(InputIterator f, InputIterator l,
+ <a name="id326234-bb"></a>basic_string(InputIterator f, InputIterator l,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a basic_string taking the allocator as parameter, and a range of iterators. 
</li>
<li>
-<pre class="literallayout">basic_string& <a name="id326307-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(basic_string) s);</pre>
+<pre class="literallayout">basic_string& <a name="id326287-bb"></a>operator=(const basic_string & s);</pre>
Effects: Copy constructs a string.
Postcondition: x == *this.
Complexity: Linear to the elements x contains. 
</li>
<li>
-<pre class="literallayout">basic_string& <a name="id326336-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(basic_string) ms);</pre>
+<pre class="literallayout">basic_string& <a name="id326316-bb"></a>operator=(basic_string && ms);</pre>
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">basic_string& <a name="id326364-bb"></a>operator=(const CharT * s);</pre>
+<pre class="literallayout">basic_string& <a name="id326344-bb"></a>operator=(const CharT * s);</pre>
Effects: Assignment from a null-terminated c-string. </li>
<li>
-<pre class="literallayout">basic_string& <a name="id326376-bb"></a>operator=(CharT c);</pre>
+<pre class="literallayout">basic_string& <a name="id326356-bb"></a>operator=(CharT c);</pre>
Effects: Assignment from character. </li>
<li>
-<pre class="literallayout"><a name="id326285-bb"></a>~basic_string();</pre>
+<pre class="literallayout"><a name="id326266-bb"></a>~basic_string();</pre>
Effects: Destroys the basic_string. All used memory is deallocated.
Throws: Nothing.
Complexity: Constant. 
@@ -270,404 +270,404 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id548127"></a><h3>
-<a name="id321734-bb"></a><code class="computeroutput">basic_string</code> public member functions</h3>
+<a name="id532081"></a><h3>
+<a name="id321717-bb"></a><code class="computeroutput">basic_string</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">iterator <a name="id321736-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id321719-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id321762-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id321744-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id321787-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id321770-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id321812-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id321795-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id321837-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id321820-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id321862-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id321845-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id321888-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id321870-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id321913-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id321896-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id321938-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id321921-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the internal allocator.
Throws: If allocator's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id321963-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id321946-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id321990-bb"></a>length() const;</pre>
+<pre class="literallayout">size_type <a name="id321972-bb"></a>length() const;</pre>
Effects: Returns the number of the elements contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id322016-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id321999-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id322041-bb"></a>resize(size_type n, CharT c) ;</pre>
+<pre class="literallayout">void <a name="id322024-bb"></a>resize(size_type n, CharT c) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id322078-bb"></a>resize(size_type n) ;</pre>
+<pre class="literallayout">void <a name="id322061-bb"></a>resize(size_type n) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default constructed.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id322111-bb"></a>reserve(size_type res_arg) ;</pre>
+<pre class="literallayout">void <a name="id322094-bb"></a>reserve(size_type res_arg) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id322135-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id322118-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id322160-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id322143-bb"></a>clear() ;</pre>
Effects: Erases all the elements of the vector.
Throws: Nothing.
Complexity: Linear to the number of elements in the vector. 
</li>
<li>
-<pre class="literallayout">bool <a name="id322185-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id322168-bb"></a>empty() const;</pre>
Effects: Returns true if the vector contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id322210-bb"></a>operator[](size_type n) ;</pre>
+<pre class="literallayout">reference <a name="id322193-bb"></a>operator[](size_type n) ;</pre>
Requires: size() < n.
Effects: Returns a reference to the nth element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id322246-bb"></a>operator[](size_type n) const;</pre>
+<pre class="literallayout">const_reference <a name="id322229-bb"></a>operator[](size_type n) const;</pre>
Requires: size() < n.
Effects: Returns a const reference to the nth element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id322282-bb"></a>at(size_type n) ;</pre>
+<pre class="literallayout">reference <a name="id322265-bb"></a>at(size_type n) ;</pre>
Requires: size() < n.
Effects: Returns a reference to the nth element from the beginning of the container.
Throws: std::range_error if n >= size()
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id322318-bb"></a>at(size_type n) const;</pre>
+<pre class="literallayout">const_reference <a name="id322301-bb"></a>at(size_type n) const;</pre>
Requires: size() < n.
Effects: Returns a const reference to the nth element from the beginning of the container.
Throws: std::range_error if n >= size()
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">basic_string & <a name="id322354-bb"></a>operator+=(const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322337-bb"></a>operator+=(const basic_string & s) ;</pre>
Effects: Appends string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322377-bb"></a>operator+=(const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322360-bb"></a>operator+=(const CharT * s) ;</pre>
Effects: Appends c-string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322396-bb"></a>operator+=(CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322379-bb"></a>operator+=(CharT c) ;</pre>
Effects: Appends character c to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322416-bb"></a>append(const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322398-bb"></a>append(const basic_string & s) ;</pre>
Effects: Appends string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322438-bb"></a>append(const basic_string & s, size_type pos, size_type n) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322421-bb"></a>append(const basic_string & s, size_type pos, size_type n) ;</pre>
Effects: Appends the range [pos, pos + n) from string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322472-bb"></a>append(const CharT * s, size_type n) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322455-bb"></a>append(const CharT * s, size_type n) ;</pre>
Effects: Appends the range [s, s + n) from c-string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322497-bb"></a>append(const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322480-bb"></a>append(const CharT * s) ;</pre>
Effects: Appends the c-string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322516-bb"></a>append(size_type n, CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322499-bb"></a>append(size_type n, CharT c) ;</pre>
Effects: Appends the n times the character c to *this. </li>
<li>
<pre class="literallayout">template<typename InputIter>
- basic_string & <a name="id322540-bb"></a>append(InputIter first, InputIter last) ;</pre>
+ basic_string & <a name="id322523-bb"></a>append(InputIter first, InputIter last) ;</pre>
Effects: Appends the range [first, last) *this. </li>
<li>
-<pre class="literallayout">void <a name="id322570-bb"></a>push_back(CharT c) ;</pre>
+<pre class="literallayout">void <a name="id322553-bb"></a>push_back(CharT c) ;</pre>
Effects: Inserts a copy of c at the end of the vector. </li>
<li>
-<pre class="literallayout">void <a name="id322587-bb"></a>pop_back() ;</pre>
+<pre class="literallayout">void <a name="id322570-bb"></a>pop_back() ;</pre>
Effects: Removes the last element from the vector. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322599-bb"></a>assign(const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322582-bb"></a>assign(const basic_string & s) ;</pre>
Effects: Assigns the value s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322622-bb"></a>assign(BOOST_MOVE_MACRO_RV_REF(basic_string) ms) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322605-bb"></a>assign(basic_string && ms) ;</pre>
Effects: Moves the resources from ms *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322645-bb"></a>assign(const basic_string & s, size_type pos, size_type n) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322626-bb"></a>assign(const basic_string & s, size_type pos, size_type n) ;</pre>
Effects: Assigns the range [pos, pos + n) from s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322677-bb"></a>assign(const CharT * s, size_type n) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322659-bb"></a>assign(const CharT * s, size_type n) ;</pre>
Effects: Assigns the range [s, s + n) from s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322701-bb"></a>assign(const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322683-bb"></a>assign(const CharT * s) ;</pre>
Effects: Assigns the c-string s to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322720-bb"></a>assign(size_type n, CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322702-bb"></a>assign(size_type n, CharT c) ;</pre>
Effects: Assigns the character c n-times to *this. </li>
<li>
<pre class="literallayout">template<typename InputIter>
- basic_string & <a name="id322744-bb"></a>assign(InputIter first, InputIter last) ;</pre>
+ basic_string & <a name="id322726-bb"></a>assign(InputIter first, InputIter last) ;</pre>
Effects: Assigns the range [first, last) to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322774-bb"></a>assign(const CharT * f, const CharT * l) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322756-bb"></a>assign(const CharT * f, const CharT * l) ;</pre>
Effects: Assigns the range [f, l) to *this. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322798-bb"></a>insert(size_type pos, const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322780-bb"></a>insert(size_type pos, const basic_string & s) ;</pre>
Effects: Inserts the string s before pos. </li>
<li>
<pre class="literallayout">basic_string &
-<a name="id322826-bb"></a>insert(size_type pos, const basic_string & s, size_type beg, size_type n) ;</pre>
+<a name="id322808-bb"></a>insert(size_type pos, const basic_string & s, size_type beg, size_type n) ;</pre>
Effects: Inserts the range [pos, pos + n) from string s before pos. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322864-bb"></a>insert(size_type pos, const CharT * s, size_type n) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322846-bb"></a>insert(size_type pos, const CharT * s, size_type n) ;</pre>
Effects: Inserts the range [s, s + n) before pos. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322893-bb"></a>insert(size_type pos, const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322875-bb"></a>insert(size_type pos, const CharT * s) ;</pre>
Effects: Inserts the c-string s before pos. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id322917-bb"></a>insert(size_type pos, size_type n, CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id322899-bb"></a>insert(size_type pos, size_type n, CharT c) ;</pre>
Effects: Inserts the character c n-times before pos. </li>
<li>
-<pre class="literallayout">iterator <a name="id322946-bb"></a>insert(iterator position, CharT c) ;</pre>
+<pre class="literallayout">iterator <a name="id322928-bb"></a>insert(iterator position, CharT c) ;</pre>
Effects: Inserts the character c before position. </li>
<li>
-<pre class="literallayout">void <a name="id322968-bb"></a>insert(iterator position, std::size_t n, CharT c) ;</pre>
+<pre class="literallayout">void <a name="id322949-bb"></a>insert(iterator position, std::size_t n, CharT c) ;</pre>
Effects: Inserts the character c n-times before position. </li>
<li>
<pre class="literallayout">template<typename InputIter>
- void <a name="id322994-bb"></a>insert(iterator p, InputIter first, InputIter last) ;</pre>
+ void <a name="id322976-bb"></a>insert(iterator p, InputIter first, InputIter last) ;</pre>
Effects: Inserts the range [first, last) before position. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323026-bb"></a>erase(size_type pos = 0, size_type n = npos) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323008-bb"></a>erase(size_type pos = 0, size_type n = npos) ;</pre>
Effects: Inserts the range [pos, pos + n). </li>
<li>
-<pre class="literallayout">iterator <a name="id323055-bb"></a>erase(iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id323037-bb"></a>erase(iterator position) ;</pre>
Effects: Erases the character pointed by position. </li>
<li>
-<pre class="literallayout">iterator <a name="id323072-bb"></a>erase(iterator first, iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id323054-bb"></a>erase(iterator first, iterator last) ;</pre>
Effects: Erases the range [first, last). </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323094-bb"></a>replace(size_type pos, size_type n, const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323075-bb"></a>replace(size_type pos, size_type n, const basic_string & s) ;</pre>
Effects: Replaces a substring of *this with the string s. </li>
<li>
<pre class="literallayout">basic_string &
-<a name="id323126-bb"></a>replace(size_type pos1, size_type n1, const basic_string & s, size_type pos2,
+<a name="id323108-bb"></a>replace(size_type pos1, size_type n1, const basic_string & s, size_type pos2,
 size_type n2) ;</pre>
Effects: Replaces a substring of *this with a substring of s. </li>
<li>
<pre class="literallayout">basic_string &
-<a name="id323168-bb"></a>replace(size_type pos, size_type n1, const CharT * s, size_type n2) ;</pre>
+<a name="id323150-bb"></a>replace(size_type pos, size_type n1, const CharT * s, size_type n2) ;</pre>
Effects: Replaces a substring of *this with the first n1 characters of s. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323202-bb"></a>replace(size_type pos, size_type n1, const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323183-bb"></a>replace(size_type pos, size_type n1, const CharT * s) ;</pre>
Effects: Replaces a substring of *this with a null-terminated character array. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323230-bb"></a>replace(size_type pos, size_type n1, size_type n2, CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323212-bb"></a>replace(size_type pos, size_type n1, size_type n2, CharT c) ;</pre>
Effects: Replaces a substring of *this with n1 copies of c. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323264-bb"></a>replace(iterator first, iterator last, const basic_string & s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323246-bb"></a>replace(iterator first, iterator last, const basic_string & s) ;</pre>
Effects: Replaces a substring of *this with the string s. </li>
<li>
<pre class="literallayout">basic_string &
-<a name="id323296-bb"></a>replace(iterator first, iterator last, const CharT * s, size_type n) ;</pre>
+<a name="id323278-bb"></a>replace(iterator first, iterator last, const CharT * s, size_type n) ;</pre>
Effects: Replaces a substring of *this with the first n characters of s. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id323330-bb"></a>replace(iterator first, iterator last, const CharT * s) ;</pre>
+<pre class="literallayout">basic_string & <a name="id323312-bb"></a>replace(iterator first, iterator last, const CharT * s) ;</pre>
Effects: Replaces a substring of *this with a null-terminated character array. </li>
<li>
-<pre class="literallayout">basic_string & <a name="id325089-bb"></a>replace(iterator first, iterator last, size_type n, CharT c) ;</pre>
+<pre class="literallayout">basic_string & <a name="id325070-bb"></a>replace(iterator first, iterator last, size_type n, CharT c) ;</pre>
Effects: Replaces a substring of *this with n copies of c. </li>
<li>
<pre class="literallayout">template<typename InputIter>
 basic_string &
- <a name="id325122-bb"></a>replace(iterator first, iterator last, InputIter f, InputIter l) ;</pre>
+ <a name="id325104-bb"></a>replace(iterator first, iterator last, InputIter f, InputIter l) ;</pre>
Effects: Replaces a substring of *this with the range [f, l) </li>
<li>
-<pre class="literallayout">size_type <a name="id325162-bb"></a>copy(CharT * s, size_type n, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325144-bb"></a>copy(CharT * s, size_type n, size_type pos = 0) const;</pre>
Effects: Copies a substring of *this to a buffer. </li>
<li>
-<pre class="literallayout">void <a name="id325191-bb"></a>swap(basic_string & x) ;</pre>
+<pre class="literallayout">void <a name="id325172-bb"></a>swap(basic_string & x) ;</pre>
Effects: Swaps the contents of two strings. </li>
<li>
-<pre class="literallayout">const CharT * <a name="id325210-bb"></a>c_str() const;</pre>
+<pre class="literallayout">const CharT * <a name="id325192-bb"></a>c_str() const;</pre>
Returns: Returns a pointer to a null-terminated array of characters representing the string's contents. For any string s it is guaranteed that the first s.size() characters in the array pointed to by s.c_str() are equal to the character in s, and that s.c_str()[s.size()] is a null character. Note, however, that it not necessarily the first null character. Characters within a string are permitted to be null. 
</li>
<li>
-<pre class="literallayout">const CharT * <a name="id325223-bb"></a>data() const;</pre>
+<pre class="literallayout">const CharT * <a name="id325205-bb"></a>data() const;</pre>
Returns: Returns a pointer to an array of characters, not necessarily null-terminated, representing the string's contents. data() is permitted, but not required, to be identical to c_str(). The first size() characters of that array are guaranteed to be identical to the characters in *this. The return value of data() is never a null pointer, even if size() is zero. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325236-bb"></a>find(const basic_string & s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325218-bb"></a>find(const basic_string & s, size_type pos = 0) const;</pre>
Effects: Searches for s as a substring of *this, beginning at character pos of *this. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325265-bb"></a>find(const CharT * s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325247-bb"></a>find(const CharT * s, size_type pos = 0) const;</pre>
Effects: Searches for a null-terminated character array as a substring of *this, beginning at character pos of *this. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325290-bb"></a>find(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325272-bb"></a>find(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches for the first n characters of s as a substring of *this, beginning at character pos of *this. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325318-bb"></a>find(CharT c, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325300-bb"></a>find(CharT c, size_type pos = 0) const;</pre>
Effects: Searches for the character c, beginning at character position pos. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325343-bb"></a>rfind(const basic_string & s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325325-bb"></a>rfind(const basic_string & s, size_type pos = npos) const;</pre>
Effects: Searches backward for s as a substring of *this, beginning at character position min(pos, size()) 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325372-bb"></a>rfind(const CharT * s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325354-bb"></a>rfind(const CharT * s, size_type pos = npos) const;</pre>
Effects: Searches backward for a null-terminated character array as a substring of *this, beginning at character min(pos, size()) 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325397-bb"></a>rfind(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325379-bb"></a>rfind(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches backward for the first n characters of s as a substring of *this, beginning at character position min(pos, size()). 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325425-bb"></a>rfind(CharT c, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325406-bb"></a>rfind(CharT c, size_type pos = npos) const;</pre>
Effects: Searches backward for a null-terminated character array as a substring of *this, beginning at character min(pos, size()). 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325450-bb"></a>find_first_of(const basic_string & s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325432-bb"></a>find_first_of(const basic_string & s, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325479-bb"></a>find_first_of(const CharT * s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325460-bb"></a>find_first_of(const CharT * s, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325504-bb"></a>find_first_of(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325486-bb"></a>find_first_of(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is equal to any character within the first n characters of s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325532-bb"></a>find_first_of(CharT c, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325513-bb"></a>find_first_of(CharT c, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is equal to c. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325557-bb"></a>find_last_of(const basic_string & s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325538-bb"></a>find_last_of(const basic_string & s, size_type pos = npos) const;</pre>
Effects: Searches backward within *this, beginning at min(pos, size()), for the first character that is equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325586-bb"></a>find_last_of(const CharT * s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325567-bb"></a>find_last_of(const CharT * s, size_type pos = npos) const;</pre>
Effects: Searches backward *this, beginning at min(pos, size()), for the first character that is equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325611-bb"></a>find_last_of(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325592-bb"></a>find_last_of(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches backward within *this, beginning at min(pos, size()), for the first character that is equal to any character within the first n characters of s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325638-bb"></a>find_last_of(CharT c, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325620-bb"></a>find_last_of(CharT c, size_type pos = npos) const;</pre>
Effects: Searches backward *this, beginning at min(pos, size()), for the first character that is equal to c. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325664-bb"></a>find_first_not_of(const basic_string & s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325645-bb"></a>find_first_not_of(const basic_string & s, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is not equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325692-bb"></a>find_first_not_of(const CharT * s, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325674-bb"></a>find_first_not_of(const CharT * s, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is not equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325718-bb"></a>find_first_not_of(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325699-bb"></a>find_first_not_of(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is not equal to any character within the first n characters of s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325745-bb"></a>find_first_not_of(CharT c, size_type pos = 0) const;</pre>
+<pre class="literallayout">size_type <a name="id325727-bb"></a>find_first_not_of(CharT c, size_type pos = 0) const;</pre>
Effects: Searches within *this, beginning at pos, for the first character that is not equal to c. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325770-bb"></a>find_last_not_of(const basic_string & s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325752-bb"></a>find_last_not_of(const basic_string & s, size_type pos = npos) const;</pre>
Effects: Searches backward within *this, beginning at min(pos, size()), for the first character that is not equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325799-bb"></a>find_last_not_of(const CharT * s, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325781-bb"></a>find_last_not_of(const CharT * s, size_type pos = npos) const;</pre>
Effects: Searches backward *this, beginning at min(pos, size()), for the first character that is not equal to any character within s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325824-bb"></a>find_last_not_of(const CharT * s, size_type pos, size_type n) const;</pre>
+<pre class="literallayout">size_type <a name="id325806-bb"></a>find_last_not_of(const CharT * s, size_type pos, size_type n) const;</pre>
Effects: Searches backward within *this, beginning at min(pos, size()), for the first character that is not equal to any character within the first n characters of s. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id325852-bb"></a>find_last_not_of(CharT c, size_type pos = npos) const;</pre>
+<pre class="literallayout">size_type <a name="id325834-bb"></a>find_last_not_of(CharT c, size_type pos = npos) const;</pre>
Effects: Searches backward *this, beginning at min(pos, size()), for the first character that is not equal to c. 
</li>
<li>
-<pre class="literallayout">basic_string <a name="id325877-bb"></a>substr(size_type pos = 0, size_type n = npos) const;</pre>
+<pre class="literallayout">basic_string <a name="id325859-bb"></a>substr(size_type pos = 0, size_type n = npos) const;</pre>
Effects: Returns a substring of *this. </li>
<li>
-<pre class="literallayout">int <a name="id325905-bb"></a>compare(const basic_string & s) const;</pre>
+<pre class="literallayout">int <a name="id325886-bb"></a>compare(const basic_string & s) const;</pre>
Effects: Three-way lexicographical comparison of s and *this. </li>
<li>
-<pre class="literallayout">int <a name="id325925-bb"></a>compare(size_type pos1, size_type n1, const basic_string & s) const;</pre>
+<pre class="literallayout">int <a name="id325907-bb"></a>compare(size_type pos1, size_type n1, const basic_string & s) const;</pre>
Effects: Three-way lexicographical comparison of s and a substring of *this. 
</li>
<li>
-<pre class="literallayout">int <a name="id325956-bb"></a>compare(size_type pos1, size_type n1, const basic_string & s,
+<pre class="literallayout">int <a name="id325938-bb"></a>compare(size_type pos1, size_type n1, const basic_string & s,
 size_type pos2, size_type n2) const;</pre>
Effects: Three-way lexicographical comparison of a substring of s and a substring of *this. 
</li>
<li>
-<pre class="literallayout">int <a name="id325997-bb"></a>compare(const CharT * s) const;</pre>
+<pre class="literallayout">int <a name="id325979-bb"></a>compare(const CharT * s) const;</pre>
Effects: Three-way lexicographical comparison of s and *this. </li>
<li>
-<pre class="literallayout">int <a name="id326014-bb"></a>compare(size_type pos1, size_type n1, const CharT * s,
+<pre class="literallayout">int <a name="id325996-bb"></a>compare(size_type pos1, size_type n1, const CharT * s,
 size_type n2 = npos) const;</pre>
Effects: Three-way lexicographical comparison of the first min(len, traits::length(s) characters of s and a substring of *this. 
</li>

Modified: sandbox/move/libs/container/doc/html/boost/container/deque.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/deque.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/deque.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -41,140 +41,139 @@
 typedef std::reverse_iterator< iterator > <a name="boost.container.deque.reverse_iterator"></a>reverse_iterator;

 // construct/copy/destruct
- deque(const allocator_type & = allocator_type());
- deque(const deque &);
- deque(BOOST_MOVE_MACRO_RV_REF(deque));
- deque(size_type, const value_type &,
+ deque(const allocator_type & = allocator_type());
+ deque(const deque &);
+ deque(deque &&);
+ deque(size_type, const value_type &,
 const allocator_type & = allocator_type());
- deque(size_type);
+ deque(size_type);
 template<typename InpIt>
- deque(InpIt, InpIt, const allocator_type & = allocator_type());
- deque& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(deque));
- deque& operator=(BOOST_MOVE_MACRO_RV_REF(deque));
- ~deque();
+ deque(InpIt, InpIt, const allocator_type & = allocator_type());
+ deque& operator=(const deque &);
+ deque& operator=(deque &&);
+ ~deque();

- // public member functions
- allocator_type get_allocator() const;
- iterator begin() ;
- iterator end() ;
- const_iterator begin() const;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- reverse_iterator rend() ;
- const_reverse_iterator rbegin() const;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- reference operator[](size_type) ;
- const_reference operator[](size_type) const;
- void priv_range_check(size_type) const;
- reference at(size_type) ;
- const_reference at(size_type) const;
- reference front() ;
- reference back() ;
- const_reference front() const;
- const_reference back() const;
- size_type size() const;
- size_type max_size() const;
- bool empty() const;
- void swap(deque &) ;
- void assign(size_type, const T &) ;
- template<typename InpIt> void assign(InpIt, InpIt) ;
- void push_back(const T &) ;
- void push_back(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- void push_front(const T &) ;
- void push_front(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- void pop_back() ;
- void pop_front() ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- void insert(const_iterator, size_type, const value_type &) ;
- template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ;
- template<class... Args> void emplace_back(Args &&...) ;
- template<class... Args> void emplace_front(Args &&...) ;
- template<class... Args> iterator emplace(const_iterator, Args &&...) ;
- void resize(size_type, const value_type &) ;
- void resize(size_type) ;
- iterator erase(const_iterator) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
+ // public member functions
+ allocator_type get_allocator() const;
+ iterator begin() ;
+ iterator end() ;
+ const_iterator begin() const;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ reverse_iterator rend() ;
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ reference operator[](size_type) ;
+ const_reference operator[](size_type) const;
+ void priv_range_check(size_type) const;
+ reference at(size_type) ;
+ const_reference at(size_type) const;
+ reference front() ;
+ reference back() ;
+ const_reference front() const;
+ const_reference back() const;
+ size_type size() const;
+ size_type max_size() const;
+ bool empty() const;
+ void swap(deque &) ;
+ void assign(size_type, const T &) ;
+ template<typename InpIt> void assign(InpIt, InpIt) ;
+ void push_back(const T &) ;
+ void push_back(value_type &&) ;
+ void push_front(const T &) ;
+ void push_front(value_type &&) ;
+ void pop_back() ;
+ void pop_front() ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ void insert(const_iterator, size_type, const value_type &) ;
+ template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ;
+ template<class... Args> void emplace_back(Args &&...) ;
+ template<class... Args> void emplace_front(Args &&...) ;
+ template<class... Args> iterator emplace(const_iterator, Args &&...) ;
+ void resize(size_type, const value_type &) ;
+ void resize(size_type) ;
+ iterator erase(const_iterator) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id489510"></a><h2>Description</h2>
+<a name="id473130"></a><h2>Description</h2>
Deque class 
<div class="refsect2" lang="en">
-<a name="id489516"></a><h3>
+<a name="id473136"></a><h3>
<a name="boost.container.dequeconstruct-copy-destruct"></a><code class="computeroutput">deque</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
-<li><pre class="literallayout"><a name="id294429-bb"></a>deque(const allocator_type & a = allocator_type());</pre></li>
-<li><pre class="literallayout"><a name="id294438-bb"></a>deque(const deque & x);</pre></li>
-<li><pre class="literallayout"><a name="id294447-bb"></a>deque(BOOST_MOVE_MACRO_RV_REF(deque) mx);</pre></li>
-<li><pre class="literallayout"><a name="id294457-bb"></a>deque(size_type n, const value_type & value,
+<li><pre class="literallayout"><a name="id294169-bb"></a>deque(const allocator_type & a = allocator_type());</pre></li>
+<li><pre class="literallayout"><a name="id294178-bb"></a>deque(const deque & x);</pre></li>
+<li><pre class="literallayout"><a name="id294187-bb"></a>deque(deque && mx);</pre></li>
+<li><pre class="literallayout"><a name="id294196-bb"></a>deque(size_type n, const value_type & value,
 const allocator_type & a = allocator_type());</pre></li>
-<li><pre class="literallayout"><a name="id294475-bb"></a>deque(size_type n);</pre></li>
+<li><pre class="literallayout"><a name="id294214-bb"></a>deque(size_type n);</pre></li>
<li><pre class="literallayout">template<typename InpIt>
- <a name="id294481-bb"></a>deque(InpIt first, InpIt last, const allocator_type & a = allocator_type());</pre></li>
-<li><pre class="literallayout">deque& <a name="id294506-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(deque) x);</pre></li>
-<li><pre class="literallayout">deque& <a name="id294516-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(deque) x);</pre></li>
-<li><pre class="literallayout"><a name="id294505-bb"></a>~deque();</pre></li>
+ <a name="id294220-bb"></a>deque(InpIt first, InpIt last, const allocator_type & a = allocator_type());</pre></li>
+<li><pre class="literallayout">deque& <a name="id294245-bb"></a>operator=(const deque & x);</pre></li>
+<li><pre class="literallayout">deque& <a name="id294254-bb"></a>operator=(deque && x);</pre></li>
+<li><pre class="literallayout"><a name="id294244-bb"></a>~deque();</pre></li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id489678"></a><h3>
-<a name="id293948-bb"></a><code class="computeroutput">deque</code> public member functions</h3>
+<a name="id473303"></a><h3>
+<a name="id293688-bb"></a><code class="computeroutput">deque</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
-<li><pre class="literallayout">allocator_type <a name="id293950-bb"></a>get_allocator() const;</pre></li>
-<li><pre class="literallayout">iterator <a name="id293956-bb"></a>begin() ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id293962-bb"></a>end() ;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id293968-bb"></a>begin() const;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id293974-bb"></a>end() const;</pre></li>
-<li><pre class="literallayout">reverse_iterator <a name="id293980-bb"></a>rbegin() ;</pre></li>
-<li><pre class="literallayout">reverse_iterator <a name="id293986-bb"></a>rend() ;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id293992-bb"></a>rbegin() const;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id293998-bb"></a>rend() const;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id294004-bb"></a>cbegin() const;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id294010-bb"></a>cend() const;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id294016-bb"></a>crbegin() const;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id294022-bb"></a>crend() const;</pre></li>
-<li><pre class="literallayout">reference <a name="id294028-bb"></a>operator[](size_type n) ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id294039-bb"></a>operator[](size_type n) const;</pre></li>
-<li><pre class="literallayout">void <a name="id294050-bb"></a>priv_range_check(size_type n) const;</pre></li>
-<li><pre class="literallayout">reference <a name="id294061-bb"></a>at(size_type n) ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id294072-bb"></a>at(size_type n) const;</pre></li>
-<li><pre class="literallayout">reference <a name="id294082-bb"></a>front() ;</pre></li>
-<li><pre class="literallayout">reference <a name="id294088-bb"></a>back() ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id294094-bb"></a>front() const;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id294100-bb"></a>back() const;</pre></li>
-<li><pre class="literallayout">size_type <a name="id294106-bb"></a>size() const;</pre></li>
-<li><pre class="literallayout">size_type <a name="id294112-bb"></a>max_size() const;</pre></li>
-<li><pre class="literallayout">bool <a name="id294118-bb"></a>empty() const;</pre></li>
-<li><pre class="literallayout">void <a name="id294124-bb"></a>swap(deque & x) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294138-bb"></a>assign(size_type n, const T & val) ;</pre></li>
-<li><pre class="literallayout">template<typename InpIt> void <a name="id294153-bb"></a>assign(InpIt first, InpIt last) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294175-bb"></a>push_back(const T & t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294186-bb"></a>push_back(BOOST_MOVE_MACRO_RV_REF(value_type) t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294196-bb"></a>push_front(const T & t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294207-bb"></a>push_front(BOOST_MOVE_MACRO_RV_REF(value_type) t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294218-bb"></a>pop_back() ;</pre></li>
-<li><pre class="literallayout">void <a name="id294224-bb"></a>pop_front() ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id294230-bb"></a>insert(const_iterator position, const T & x) ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id294246-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(value_type) mx) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294261-bb"></a>insert(const_iterator pos, size_type n, const value_type & x) ;</pre></li>
+<li><pre class="literallayout">allocator_type <a name="id293690-bb"></a>get_allocator() const;</pre></li>
+<li><pre class="literallayout">iterator <a name="id293696-bb"></a>begin() ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id293702-bb"></a>end() ;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id293708-bb"></a>begin() const;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id293714-bb"></a>end() const;</pre></li>
+<li><pre class="literallayout">reverse_iterator <a name="id293720-bb"></a>rbegin() ;</pre></li>
+<li><pre class="literallayout">reverse_iterator <a name="id293726-bb"></a>rend() ;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id293732-bb"></a>rbegin() const;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id293738-bb"></a>rend() const;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id293744-bb"></a>cbegin() const;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id293750-bb"></a>cend() const;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id293756-bb"></a>crbegin() const;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id293762-bb"></a>crend() const;</pre></li>
+<li><pre class="literallayout">reference <a name="id293768-bb"></a>operator[](size_type n) ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id293779-bb"></a>operator[](size_type n) const;</pre></li>
+<li><pre class="literallayout">void <a name="id293790-bb"></a>priv_range_check(size_type n) const;</pre></li>
+<li><pre class="literallayout">reference <a name="id293801-bb"></a>at(size_type n) ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id293812-bb"></a>at(size_type n) const;</pre></li>
+<li><pre class="literallayout">reference <a name="id293822-bb"></a>front() ;</pre></li>
+<li><pre class="literallayout">reference <a name="id293828-bb"></a>back() ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id293834-bb"></a>front() const;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id293840-bb"></a>back() const;</pre></li>
+<li><pre class="literallayout">size_type <a name="id293846-bb"></a>size() const;</pre></li>
+<li><pre class="literallayout">size_type <a name="id293852-bb"></a>max_size() const;</pre></li>
+<li><pre class="literallayout">bool <a name="id293858-bb"></a>empty() const;</pre></li>
+<li><pre class="literallayout">void <a name="id293864-bb"></a>swap(deque & x) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293878-bb"></a>assign(size_type n, const T & val) ;</pre></li>
+<li><pre class="literallayout">template<typename InpIt> void <a name="id293893-bb"></a>assign(InpIt first, InpIt last) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293915-bb"></a>push_back(const T & t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293926-bb"></a>push_back(value_type && t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293936-bb"></a>push_front(const T & t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293947-bb"></a>push_front(value_type && t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id293958-bb"></a>pop_back() ;</pre></li>
+<li><pre class="literallayout">void <a name="id293964-bb"></a>pop_front() ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id293970-bb"></a>insert(const_iterator position, const T & x) ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id293986-bb"></a>insert(const_iterator position, value_type && mx) ;</pre></li>
+<li><pre class="literallayout">void <a name="id294001-bb"></a>insert(const_iterator pos, size_type n, const value_type & x) ;</pre></li>
<li><pre class="literallayout">template<typename InpIt>
- void <a name="id294282-bb"></a>insert(const_iterator pos, InpIt first, InpIt last) ;</pre></li>
-<li><pre class="literallayout">template<class... Args> void <a name="id294308-bb"></a>emplace_back(Args &&... args) ;</pre></li>
-<li><pre class="literallayout">template<class... Args> void <a name="id294327-bb"></a>emplace_front(Args &&... args) ;</pre></li>
-<li><pre class="literallayout">template<class... Args> iterator <a name="id294346-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294370-bb"></a>resize(size_type new_size, const value_type & x) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294386-bb"></a>resize(size_type new_size) ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id294397-bb"></a>erase(const_iterator pos) ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id294408-bb"></a>erase(const_iterator first, const_iterator last) ;</pre></li>
-<li><pre class="literallayout">void <a name="id294423-bb"></a>clear() ;</pre></li>
+ void <a name="id294022-bb"></a>insert(const_iterator pos, InpIt first, InpIt last) ;</pre></li>
+<li><pre class="literallayout">template<class... Args> void <a name="id294048-bb"></a>emplace_back(Args &&... args) ;</pre></li>
+<li><pre class="literallayout">template<class... Args> void <a name="id294067-bb"></a>emplace_front(Args &&... args) ;</pre></li>
+<li><pre class="literallayout">template<class... Args> iterator <a name="id294086-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre></li>
+<li><pre class="literallayout">void <a name="id294110-bb"></a>resize(size_type new_size, const value_type & x) ;</pre></li>
+<li><pre class="literallayout">void <a name="id294126-bb"></a>resize(size_type new_size) ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id294137-bb"></a>erase(const_iterator pos) ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id294148-bb"></a>erase(const_iterator first, const_iterator last) ;</pre></li>
+<li><pre class="literallayout">void <a name="id294163-bb"></a>clear() ;</pre></li>
</ol></div>
</div>
</div>

Modified: sandbox/move/libs/container/doc/html/boost/container/flat_map.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/flat_map.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/flat_map.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -54,75 +54,74 @@
 typedef Alloc <a name="boost.container.flat_map.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- flat_map(const Pred & = Pred(), const allocator_type & = allocator_type());
+ flat_map(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_map(InputIterator, InputIterator, const Pred & = Pred(),
+ flat_map(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_map(ordered_unique_range_t, InputIterator, InputIterator,
+ flat_map(ordered_unique_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- flat_map(const flat_map< Key, T, Pred, Alloc > &);
- flat_map(BOOST_MOVE_MACRO_RV_REF(flat_map));
- flat_map& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_map));
- flat_map& operator=(BOOST_MOVE_MACRO_RV_REF(flat_map));
+ flat_map(const flat_map< Key, T, Pred, Alloc > &);
+ flat_map(flat_map &&);
+ flat_map& operator=(const flat_map &);
+ flat_map& operator=(flat_map &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- const_iterator cbegin() const;
- iterator end() ;
- const_iterator end() const;
- const_iterator cend() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- const_reverse_iterator crbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- T & operator[](const key_type &) ;
- T & operator[](BOOST_MOVE_MACRO_RV_REF(key_type)) ;
- T & at(const key_type &) ;
- const T & at(const key_type &) const;
- void swap(flat_map &) ;
- std::pair< iterator, bool > insert(const value_type &) ;
- std::pair< iterator, bool > insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- std::pair< iterator, bool >
- insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type)) ;
- iterator insert(const_iterator, const value_type &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(impl_value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- void shrink_to_fit() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ const_iterator cbegin() const;
+ iterator end() ;
+ const_iterator end() const;
+ const_iterator cend() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator crbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ T & operator[](const key_type &) ;
+ T & operator[](key_type &&) ;
+ T & at(const key_type &) ;
+ const T & at(const key_type &) const;
+ void swap(flat_map &) ;
+ std::pair< iterator, bool > insert(const value_type &) ;
+ std::pair< iterator, bool > insert(value_type &&) ;
+ std::pair< iterator, bool > insert(impl_value_type &&) ;
+ iterator insert(const_iterator, const value_type &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ iterator insert(const_iterator, impl_value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ void shrink_to_fit() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
- size_type capacity() const;
- void reserve(size_type) ;
+ equal_range(const key_type &) const;
+ size_type capacity() const;
+ void reserve(size_type) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id492395"></a><h2>Description</h2>
+<a name="id476024"></a><h2>Description</h2>
A flat_map is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval of values of another type T based on the keys. The flat_map class supports random-access iterators.
A flat_map satisfies all of the requirements of a container and of a reversible container and of an associative container. A flat_map also provides most operations described for unique keys. For a 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>).
@@ -130,20 +129,20 @@
flat_map is similar to std::map but it's implemented like an ordered vector. This means that inserting a new element into a flat_map invalidates previous iterators and references
Erasing an element of a flat_map invalidates iterators and references pointing to elements that come after (their keys are bigger) the erased element. 
<div class="refsect2" lang="en">
-<a name="id492418"></a><h3>
+<a name="id476047"></a><h3>
<a name="boost.container.flat_mapconstruct-copy-destruct"></a><code class="computeroutput">flat_map</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id296258-bb"></a>flat_map(const Pred & comp = Pred(),
+<pre class="literallayout"><a name="id296127-bb"></a>flat_map(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_map using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id296287-bb"></a>flat_map(InputIterator first, InputIterator last,
+ <a name="id296156-bb"></a>flat_map(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_map using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
@@ -151,7 +150,7 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id296332-bb"></a>flat_map(ordered_unique_range_t, InputIterator first, InputIterator last,
+ <a name="id296200-bb"></a>flat_map(ordered_unique_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_map using the specified comparison object and allocator, and inserts elements from the ordered unique range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -159,23 +158,23 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id296387-bb"></a>flat_map(const flat_map< Key, T, Pred, Alloc > & x);</pre>
+<pre class="literallayout"><a name="id296255-bb"></a>flat_map(const flat_map< Key, T, Pred, Alloc > & x);</pre>
Effects: Copy constructs a flat_map.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id296410-bb"></a>flat_map(BOOST_MOVE_MACRO_RV_REF(flat_map) x);</pre>
+<pre class="literallayout"><a name="id296278-bb"></a>flat_map(flat_map && x);</pre>
Effects: Move constructs a flat_map. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">flat_map& <a name="id296438-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_map) x);</pre>
+<pre class="literallayout">flat_map& <a name="id296306-bb"></a>operator=(const flat_map & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">flat_map& <a name="id296461-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(flat_map) mx);</pre>
+<pre class="literallayout">flat_map& <a name="id296328-bb"></a>operator=(flat_map && mx);</pre>
Effects: Move constructs a flat_map. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
@@ -183,182 +182,179 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id492683"></a><h3>
-<a name="id294896-bb"></a><code class="computeroutput">flat_map</code> public member functions</h3>
+<a name="id476317"></a><h3>
+<a name="id294765-bb"></a><code class="computeroutput">flat_map</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id294899-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id294767-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id294919-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id294788-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id294938-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id294807-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id294958-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id294964-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id294826-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id294832-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id294970-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id294838-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id294995-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id294863-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id295020-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id294888-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295045-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id294914-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id295070-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id294939-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id295096-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id294964-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id295121-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id294989-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id295146-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id295014-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id295171-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id295040-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id295196-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id295065-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id295222-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id295090-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id295247-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id295115-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id295272-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id295140-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id295297-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id295166-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id295322-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id295191-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">T & <a name="id295348-bb"></a>operator[](const key_type & k) ;</pre>
+<pre class="literallayout">T & <a name="id295216-bb"></a>operator[](const key_type & k) ;</pre>
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.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">T & <a name="id295367-bb"></a>operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk) ;</pre>
+<pre class="literallayout">T & <a name="id295235-bb"></a>operator[](key_type && mk) ;</pre>
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.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">T & <a name="id295386-bb"></a>at(const key_type & k) ;</pre>
+<pre class="literallayout">T & <a name="id295254-bb"></a>at(const key_type & k) ;</pre>
Returns: A 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. 
</li>
<li>
-<pre class="literallayout">const T & <a name="id295400-bb"></a>at(const key_type & k) const;</pre>
+<pre class="literallayout">const T & <a name="id295269-bb"></a>at(const key_type & k) const;</pre>
Returns: A 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. 
</li>
<li>
-<pre class="literallayout">void <a name="id295415-bb"></a>swap(flat_map & x) ;</pre>
+<pre class="literallayout">void <a name="id295283-bb"></a>swap(flat_map & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id295447-bb"></a>insert(const value_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id295316-bb"></a>insert(const value_type & x) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id295484-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id295353-bb"></a>insert(value_type && x) ;</pre>
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.
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool >
-<a name="id295522-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id295390-bb"></a>insert(impl_value_type && x) ;</pre>
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.
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295559-bb"></a>insert(const_iterator position, const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id295427-bb"></a>insert(const_iterator position, const value_type & x) ;</pre>
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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295601-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id295469-bb"></a>insert(const_iterator position, value_type && x) ;</pre>
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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295643-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id295511-bb"></a>insert(const_iterator position, impl_value_type && x) ;</pre>
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 search time (constant if x is inserted right before p) plus insertion linear to the elements with bigger keys than x.
@@ -366,14 +362,14 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id295685-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id295553-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element.
Complexity: N log(size()+N) (N is the distance from i to j) search time plus N*size() insertion time.
Note: If an element it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id295733-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id295601-bb"></a>emplace(Args &&... args) ;</pre>
Effects: Inserts an object 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.
@@ -381,97 +377,97 @@
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id295778-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id295647-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295829-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id295697-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Linear to the elements with keys bigger than position
Note: Invalidates elements with keys not less than the erased element. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id295865-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id295733-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295895-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id295763-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: size()*N where N is the distance from first to last.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">void <a name="id295936-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id295804-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">void <a name="id295961-bb"></a>shrink_to_fit() ;</pre>
+<pre class="literallayout">void <a name="id295829-bb"></a>shrink_to_fit() ;</pre>
Effects: Tries to deallocate the excess of memory created Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id295987-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id295856-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id296011-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id295880-bb"></a>find(const key_type & x) const;</pre>
Returns: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic.s 
</li>
<li>
-<pre class="literallayout">size_type <a name="id296035-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id295904-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id296059-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id295928-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id296083-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id295952-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id296107-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id295976-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id296131-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id296000-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id296155-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id296024-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id296179-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id296048-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">size_type <a name="id296203-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id296072-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id296228-bb"></a>reserve(size_type count) ;</pre>
+<pre class="literallayout">void <a name="id296097-bb"></a>reserve(size_type count) ;</pre>
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.

Modified: sandbox/move/libs/container/doc/html/boost/container/flat_multimap.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/flat_multimap.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/flat_multimap.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -54,86 +54,86 @@
 typedef Alloc <a name="boost.container.flat_multimap.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- flat_multimap(const Pred & = Pred(),
+ flat_multimap(const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_multimap(InputIterator, InputIterator, const Pred & = Pred(),
+ flat_multimap(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_multimap(ordered_range_t, InputIterator, InputIterator,
+ flat_multimap(ordered_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- flat_multimap(const flat_multimap< Key, T, Pred, Alloc > &);
- flat_multimap(BOOST_MOVE_MACRO_RV_REF(flat_multimap));
- flat_multimap& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multimap));
- flat_multimap& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multimap));
+ flat_multimap(const flat_multimap< Key, T, Pred, Alloc > &);
+ flat_multimap(flat_multimap &&);
+ flat_multimap& operator=(const flat_multimap &);
+ flat_multimap& operator=(flat_multimap &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(flat_multimap &) ;
- iterator insert(const value_type &) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type)) ;
- iterator insert(const_iterator, const value_type &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(impl_value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- void shrink_to_fit() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(flat_multimap &) ;
+ iterator insert(const value_type &) ;
+ iterator insert(value_type &&) ;
+ iterator insert(impl_value_type &&) ;
+ iterator insert(const_iterator, const value_type &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ iterator insert(const_iterator, impl_value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ void shrink_to_fit() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
- size_type capacity() const;
- void reserve(size_type) ;
+ equal_range(const key_type &) const;
+ size_type capacity() const;
+ void reserve(size_type) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id497285"></a><h2>Description</h2>
+<a name="id480922"></a><h2>Description</h2>
A flat_multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. The flat_multimap class supports random-access iterators.
A flat_multimap satisfies all of the requirements of a container and of a reversible container and of an associative container. For a 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>).
Alloc is the allocator to allocate the value_types (e.g. allocator< std::pair<Key, T> >). 
<div class="refsect2" lang="en">
-<a name="id497303"></a><h3>
+<a name="id480940"></a><h3>
<a name="boost.container.flat_multimapconstruct-copy-destruct"></a><code class="computeroutput">flat_multimap</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id297871-bb"></a>flat_multimap(const Pred & comp = Pred(),
+<pre class="literallayout"><a name="id297787-bb"></a>flat_multimap(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_multimap using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id297900-bb"></a>flat_multimap(InputIterator first, InputIterator last,
+ <a name="id297816-bb"></a>flat_multimap(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
@@ -141,7 +141,7 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id297944-bb"></a>flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
+ <a name="id297860-bb"></a>flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -149,157 +149,155 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id298001-bb"></a>flat_multimap(const flat_multimap< Key, T, Pred, Alloc > & x);</pre>
+<pre class="literallayout"><a name="id297916-bb"></a>flat_multimap(const flat_multimap< Key, T, Pred, Alloc > & x);</pre>
Effects: Copy constructs a flat_multimap.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id298024-bb"></a>flat_multimap(BOOST_MOVE_MACRO_RV_REF(flat_multimap) x);</pre>
+<pre class="literallayout"><a name="id297939-bb"></a>flat_multimap(flat_multimap && x);</pre>
Effects: Move constructs a flat_multimap. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">flat_multimap& <a name="id298052-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multimap) x);</pre>
+<pre class="literallayout">flat_multimap& <a name="id297967-bb"></a>operator=(const flat_multimap & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">flat_multimap& <a name="id298075-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(flat_multimap) mx);</pre>
+<pre class="literallayout">flat_multimap& <a name="id297990-bb"></a>operator=(flat_multimap && mx);</pre>
Effects: this->swap(x.get()).
Complexity: Constant. 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id497563"></a><h3>
-<a name="id296614-bb"></a><code class="computeroutput">flat_multimap</code> public member functions</h3>
+<a name="id481206"></a><h3>
+<a name="id296480-bb"></a><code class="computeroutput">flat_multimap</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id296616-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id296482-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id296636-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id296502-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id296656-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id296522-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id296675-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id296681-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id296541-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id296547-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id296687-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id296553-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id296712-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id296578-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id296737-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id296603-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id296762-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id296628-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id296788-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id296654-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id296813-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id296679-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id296838-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id296704-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id296863-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id296729-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id296888-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id296754-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id296914-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id296780-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id296939-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id296805-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id296964-bb"></a>swap(flat_multimap & x) ;</pre>
+<pre class="literallayout">void <a name="id296830-bb"></a>swap(flat_multimap & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id296996-bb"></a>insert(const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id296862-bb"></a>insert(const value_type & x) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297028-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id296894-bb"></a>insert(value_type && x) ;</pre>
Effects: Inserts a new value move-constructed from 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297059-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id297062-bb"></a>insert(impl_value_type && x) ;</pre>
Effects: Inserts a new value move-constructed from 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297178-bb"></a>insert(const_iterator position, const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id297093-bb"></a>insert(const_iterator position, const value_type & x) ;</pre>
Effects: Inserts a copy of 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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297220-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id297135-bb"></a>insert(const_iterator position, value_type && x) ;</pre>
Effects: Inserts a value 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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297262-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id297177-bb"></a>insert(const_iterator position, impl_value_type && x) ;</pre>
Effects: Inserts a value 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 search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.
@@ -307,111 +305,111 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id297304-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id297219-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) .
Complexity: N log(size()+N) (N is the distance from i to j) search time plus N*size() insertion time.
Note: If an element it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id297352-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id297267-bb"></a>emplace(Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id297391-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id297307-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297442-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id297357-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Linear to the elements with keys bigger than position
Note: Invalidates elements with keys not less than the erased element. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id297478-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id297393-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297508-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id297423-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: size()*N where N is the distance from first to last.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">void <a name="id297548-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id297464-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">void <a name="id297574-bb"></a>shrink_to_fit() ;</pre>
+<pre class="literallayout">void <a name="id297489-bb"></a>shrink_to_fit() ;</pre>
Effects: Tries to deallocate the excess of memory created Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297600-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id297516-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id297624-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id297540-bb"></a>find(const key_type & x) const;</pre>
Returns: An const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id297648-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id297564-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297672-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id297588-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id297696-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id297612-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id297720-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id297636-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id297744-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id297660-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id297768-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id297684-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id297792-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id297708-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">size_type <a name="id297816-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id297732-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id297841-bb"></a>reserve(size_type count) ;</pre>
+<pre class="literallayout">void <a name="id297757-bb"></a>reserve(size_type count) ;</pre>
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.

Modified: sandbox/move/libs/container/doc/html/boost/container/flat_multiset.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/flat_multiset.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/flat_multiset.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -53,238 +53,237 @@
 typedef tree_t::stored_allocator_type <a name="boost.container.flat_multiset.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- flat_multiset(const Pred & = Pred(),
+ flat_multiset(const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_multiset(InputIterator, InputIterator, const Pred & = Pred(),
+ flat_multiset(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_multiset(ordered_range_t, InputIterator, InputIterator,
+ flat_multiset(ordered_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- flat_multiset(const flat_multiset< T, Pred, Alloc > &);
- flat_multiset(BOOST_MOVE_MACRO_RV_REF(flat_multiset));
- flat_multiset& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multiset));
- flat_multiset& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multiset));
+ flat_multiset(const flat_multiset< T, Pred, Alloc > &);
+ flat_multiset(flat_multiset &&);
+ flat_multiset& operator=(const flat_multiset &);
+ flat_multiset& operator=(flat_multiset &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- const_iterator cbegin() const;
- iterator end() ;
- const_iterator end() const;
- const_iterator cend() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- const_reverse_iterator crbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(flat_multiset &) ;
- iterator insert(const T &) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- void shrink_to_fit() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ const_iterator cbegin() const;
+ iterator end() ;
+ const_iterator end() const;
+ const_iterator cend() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator crbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(flat_multiset &) ;
+ iterator insert(const T &) ;
+ iterator insert(value_type &&) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ void shrink_to_fit() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
- size_type capacity() const;
- void reserve(size_type) ;
+ equal_range(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
+ size_type capacity() const;
+ void reserve(size_type) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id505647"></a><h2>Description</h2>
+<a name="id489304"></a><h2>Description</h2>
flat_multiset is a Sorted Associative Container that stores objects of type Key. flat_multiset is a Simple Associative Container, meaning that its value type, as well as its key type, is Key. flat_Multiset can store multiple copies of the same key value.
flat_multiset is similar to std::multiset but it's implemented like an ordered vector. This means that inserting a new element into a flat_multiset invalidates previous iterators and references
Erasing an element of a flat_multiset invalidates iterators and references pointing to elements that come after (their keys are equal or bigger) the erased element. 
<div class="refsect2" lang="en">
-<a name="id505658"></a><h3>
+<a name="id489315"></a><h3>
<a name="boost.container.flat_multisetconstruct-copy-destruct"></a><code class="computeroutput">flat_multiset</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
-<li><pre class="literallayout"><a name="id302858-bb"></a>flat_multiset(const Pred & comp = Pred(),
+<li><pre class="literallayout"><a name="id303371-bb"></a>flat_multiset(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre></li>
<li><pre class="literallayout">template<typename InputIterator>
- <a name="id302874-bb"></a>flat_multiset(InputIterator first, InputIterator last,
+ <a name="id303386-bb"></a>flat_multiset(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre></li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id303591-bb"></a>flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
+ <a name="id303567-bb"></a>flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_multiset using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last ). This function is more efficient than the normal range creation for ordered ranges.
Requires: [first ,last) must be ordered according to the predicate.
Complexity: Linear in N. 
</li>
-<li><pre class="literallayout"><a name="id303648-bb"></a>flat_multiset(const flat_multiset< T, Pred, Alloc > & x);</pre></li>
-<li><pre class="literallayout"><a name="id303657-bb"></a>flat_multiset(BOOST_MOVE_MACRO_RV_REF(flat_multiset) x);</pre></li>
-<li><pre class="literallayout">flat_multiset& <a name="id303667-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multiset) x);</pre></li>
-<li><pre class="literallayout">flat_multiset& <a name="id303676-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(flat_multiset) mx);</pre></li>
+<li><pre class="literallayout"><a name="id303623-bb"></a>flat_multiset(const flat_multiset< T, Pred, Alloc > & x);</pre></li>
+<li><pre class="literallayout"><a name="id303633-bb"></a>flat_multiset(flat_multiset && x);</pre></li>
+<li><pre class="literallayout">flat_multiset& <a name="id303641-bb"></a>operator=(const flat_multiset & x);</pre></li>
+<li><pre class="literallayout">flat_multiset& <a name="id303651-bb"></a>operator=(flat_multiset && mx);</pre></li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id505839"></a><h3>
-<a name="id301661-bb"></a><code class="computeroutput">flat_multiset</code> public member functions</h3>
+<a name="id490047"></a><h3>
+<a name="id302173-bb"></a><code class="computeroutput">flat_multiset</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id301663-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id302175-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id301684-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id302196-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id301703-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id302215-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id301722-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id301728-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id302234-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id302240-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id301734-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id302246-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301759-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id302271-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301784-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id302297-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id301810-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id302322-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301835-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id302347-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301860-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id302372-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id301885-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id302397-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id301910-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id302423-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id301936-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id302448-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id301961-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id302473-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id301986-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id302498-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id302011-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id302523-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id302036-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id302549-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id302062-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id302574-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id302087-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id302599-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id302112-bb"></a>swap(flat_multiset & x) ;</pre>
+<pre class="literallayout">void <a name="id302624-bb"></a>swap(flat_multiset & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302144-bb"></a>insert(const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id302657-bb"></a>insert(const T & x) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302176-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id302688-bb"></a>insert(value_type && x) ;</pre>
Effects: Inserts a new value_type move constructed from 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302207-bb"></a>insert(const_iterator p, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id302719-bb"></a>insert(const_iterator p, const T & x) ;</pre>
Effects: Inserts a copy of 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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302249-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id302761-bb"></a>insert(const_iterator position, value_type && x) ;</pre>
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.
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.
@@ -292,111 +291,111 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id302291-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id302803-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) .
Complexity: N log(size()+N) (N is the distance from i to j) search time plus N*size() insertion time.
Note: If an element it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id302339-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id302851-bb"></a>emplace(Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id302378-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id302891-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302429-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id302941-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Linear to the elements with keys bigger than position
Note: Invalidates elements with keys not less than the erased element. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id302465-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id302977-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302495-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id303007-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: size()*N where N is the distance from first to last.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">void <a name="id302536-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id303048-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">void <a name="id302561-bb"></a>shrink_to_fit() ;</pre>
+<pre class="literallayout">void <a name="id303073-bb"></a>shrink_to_fit() ;</pre>
Effects: Tries to deallocate the excess of memory created Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302587-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id303099-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id302611-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id303123-bb"></a>find(const key_type & x) const;</pre>
Returns: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic.s 
</li>
<li>
-<pre class="literallayout">size_type <a name="id302635-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id303147-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302659-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id303171-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id302683-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id303195-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id302707-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id303219-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id302731-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id303243-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id302755-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id303267-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id302779-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id303291-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">size_type <a name="id302803-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id303315-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id302828-bb"></a>reserve(size_type count) ;</pre>
+<pre class="literallayout">void <a name="id303341-bb"></a>reserve(size_type count) ;</pre>
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.

Modified: sandbox/move/libs/container/doc/html/boost/container/flat_set.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/flat_set.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/flat_set.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -53,86 +53,86 @@
 typedef tree_t::stored_allocator_type <a name="boost.container.flat_set.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- flat_set(const Pred & = Pred(), const allocator_type & = allocator_type());
+ flat_set(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_set(InputIterator, InputIterator, const Pred & = Pred(),
+ flat_set(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- flat_set(ordered_unique_range_t, InputIterator, InputIterator,
+ flat_set(ordered_unique_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- flat_set(const flat_set< T, Pred, Alloc > &);
- flat_set(BOOST_MOVE_MACRO_RV_REF(flat_set));
- flat_set& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_set));
- flat_set& operator=(BOOST_MOVE_MACRO_RV_REF(flat_set));
+ flat_set(const flat_set< T, Pred, Alloc > &);
+ flat_set(flat_set &&);
+ flat_set& operator=(const flat_set &);
+ flat_set& operator=(flat_set &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- const_iterator cbegin() const;
- iterator end() ;
- const_iterator end() const;
- const_iterator cend() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- const_reverse_iterator crbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(flat_set &) ;
- std::pair< iterator, bool > insert(const T &) ;
- std::pair< iterator, bool > insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- void shrink_to_fit() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ const_iterator cbegin() const;
+ iterator end() ;
+ const_iterator end() const;
+ const_iterator cend() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator crbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(flat_set &) ;
+ std::pair< iterator, bool > insert(const T &) ;
+ std::pair< iterator, bool > insert(value_type &&) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ void shrink_to_fit() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
- size_type capacity() const;
- void reserve(size_type) ;
+ equal_range(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
+ size_type capacity() const;
+ void reserve(size_type) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id500996"></a><h2>Description</h2>
+<a name="id484643"></a><h2>Description</h2>
flat_set is a Sorted Associative Container that stores objects of type Key. flat_set is a Simple Associative Container, meaning that its value type, as well as its key type, is Key. It is also a Unique Associative Container, meaning that no two elements are the same.
flat_set is similar to std::set but it's implemented like an ordered vector. This means that inserting a new element into a flat_set invalidates previous iterators and references
Erasing an element of a flat_set invalidates iterators and references pointing to elements that come after (their keys are bigger) the erased element. 
<div class="refsect2" lang="en">
-<a name="id501007"></a><h3>
+<a name="id484654"></a><h3>
<a name="boost.container.flat_setconstruct-copy-destruct"></a><code class="computeroutput">flat_set</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id301333-bb"></a>flat_set(const Pred & comp = Pred(),
+<pre class="literallayout"><a name="id301848-bb"></a>flat_set(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_map using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id301362-bb"></a>flat_set(InputIterator first, InputIterator last,
+ <a name="id301877-bb"></a>flat_set(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty map using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
@@ -140,7 +140,7 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id301406-bb"></a>flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
+ <a name="id301921-bb"></a>flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty flat_set using the specified comparison object and allocator, and inserts elements from the ordered unique range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -148,169 +148,168 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id301462-bb"></a>flat_set(const flat_set< T, Pred, Alloc > & x);</pre>
+<pre class="literallayout"><a name="id301976-bb"></a>flat_set(const flat_set< T, Pred, Alloc > & x);</pre>
Effects: Copy constructs a map.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id301484-bb"></a>flat_set(BOOST_MOVE_MACRO_RV_REF(flat_set) mx);</pre>
+<pre class="literallayout"><a name="id301999-bb"></a>flat_set(flat_set && mx);</pre>
Effects: Move constructs a map. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">flat_set& <a name="id301514-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_set) x);</pre>
+<pre class="literallayout">flat_set& <a name="id302028-bb"></a>operator=(const flat_set & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">flat_set& <a name="id301537-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(flat_set) mx);</pre>
+<pre class="literallayout">flat_set& <a name="id302051-bb"></a>operator=(flat_set && mx);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id501267"></a><h3>
-<a name="id298739-bb"></a><code class="computeroutput">flat_set</code> public member functions</h3>
+<a name="id484919"></a><h3>
+<a name="id298652-bb"></a><code class="computeroutput">flat_set</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id298741-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id298654-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id298762-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id298675-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id298781-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id298694-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id298800-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id298806-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id298713-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id298719-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id298812-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id298725-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id298837-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id298750-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id298862-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id298776-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id298888-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id298801-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id298913-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id298826-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id298938-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id298851-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id298963-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id298876-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id298988-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id298902-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id299014-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id298927-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id299039-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id298952-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id299064-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id298977-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id299089-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id299002-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id299114-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id299028-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id299140-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id299053-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id299165-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id299078-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id299190-bb"></a>swap(flat_set & x) ;</pre>
+<pre class="literallayout">void <a name="id299103-bb"></a>swap(flat_set & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id299222-bb"></a>insert(const T & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id299136-bb"></a>insert(const T & x) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id299260-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id299173-bb"></a>insert(value_type && x) ;</pre>
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.
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id299297-bb"></a>insert(const_iterator p, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id299210-bb"></a>insert(const_iterator p, const T & x) ;</pre>
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 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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id300718-bb"></a>insert(const_iterator position,
- BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id301232-bb"></a>insert(const_iterator position, value_type && x) ;</pre>
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 search time (constant if x is inserted right before p) plus insertion linear to the elements with bigger keys than x.
@@ -318,14 +317,14 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id300760-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id301274-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element.
Complexity: N log(size()+N) (N is the distance from i to j) search time plus N*size() insertion time.
Note: If an element it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id300808-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id301322-bb"></a>emplace(Args &&... args) ;</pre>
Effects: Inserts an object 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.
@@ -333,97 +332,97 @@
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id300853-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id301368-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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 it's inserted it might invalidate elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id300904-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id301418-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Linear to the elements with keys bigger than position
Note: Invalidates elements with keys not less than the erased element. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id300940-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id301454-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id300970-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id301484-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: size()*N where N is the distance from first to last.
Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys. 
</li>
<li>
-<pre class="literallayout">void <a name="id301010-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id301525-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">void <a name="id301036-bb"></a>shrink_to_fit() ;</pre>
+<pre class="literallayout">void <a name="id301550-bb"></a>shrink_to_fit() ;</pre>
Effects: Tries to deallocate the excess of memory created Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id301062-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id301577-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301086-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id301601-bb"></a>find(const key_type & x) const;</pre>
Returns: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic.s 
</li>
<li>
-<pre class="literallayout">size_type <a name="id301110-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id301625-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id301134-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id301649-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301158-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id301673-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id301182-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id301697-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id301206-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id301721-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id301230-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id301745-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id301254-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id301769-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">size_type <a name="id301278-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id301793-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id301303-bb"></a>reserve(size_type count) ;</pre>
+<pre class="literallayout">void <a name="id301818-bb"></a>reserve(size_type count) ;</pre>
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.

Modified: sandbox/move/libs/container/doc/html/boost/container/list.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/list.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/list.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -47,81 +47,81 @@
 typedef std::reverse_iterator< const_iterator > const_reverse_iterator;

 // construct/copy/destruct
- list(const allocator_type & = A());
- list(size_type);
- list(size_type, const T &, const A & = A());
- list(const list &);
- list(BOOST_MOVE_MACRO_RV_REF(list));
- template<typename InpIt> list(InpIt, InpIt, const A & = A());
- list& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(ThisType));
- list& operator=(BOOST_MOVE_MACRO_RV_REF(ThisType));
- ~list();
+ list(const allocator_type & = A());
+ list(size_type);
+ list(size_type, const T &, const A & = A());
+ list(const list &);
+ list(list &&);
+ template<typename InpIt> list(InpIt, InpIt, const A & = A());
+ list& operator=(const ThisType &);
+ list& operator=(ThisType &&);
+ ~list();

- // public member functions
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- void clear() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void push_front(const T &) ;
- void push_front(BOOST_MOVE_MACRO_RV_REF(T)) ;
- void push_back(const T &) ;
- void push_back(BOOST_MOVE_MACRO_RV_REF(T)) ;
- void pop_front() ;
- void pop_back() ;
- reference front() ;
- const_reference front() const;
- reference back() ;
- const_reference back() const;
- void resize(size_type, const T &) ;
- void resize(size_type) ;
- void swap(ThisType &) ;
- void insert(const_iterator, size_type, const T &) ;
- template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(T)) ;
- template<class... Args> void emplace_back(Args &&...) ;
- template<class... Args> void emplace_front(Args &&...) ;
- template<class... Args> iterator emplace(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- iterator erase(const_iterator, const_iterator) ;
- void assign(size_type, const T &) ;
- template<typename InpIt> void assign(InpIt, InpIt) ;
- void splice(iterator, ThisType &) ;
- void splice(const_iterator, ThisType &, const_iterator) ;
- void splice(const_iterator, ThisType &, const_iterator, const_iterator) ;
- void splice(const_iterator, ThisType &, const_iterator, const_iterator,
+ // public member functions
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ void clear() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void push_front(const T &) ;
+ void push_front(T &&) ;
+ void push_back(const T &) ;
+ void push_back(T &&) ;
+ void pop_front() ;
+ void pop_back() ;
+ reference front() ;
+ const_reference front() const;
+ reference back() ;
+ const_reference back() const;
+ void resize(size_type, const T &) ;
+ void resize(size_type) ;
+ void swap(ThisType &) ;
+ void insert(const_iterator, size_type, const T &) ;
+ template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, T &&) ;
+ template<class... Args> void emplace_back(Args &&...) ;
+ template<class... Args> void emplace_front(Args &&...) ;
+ template<class... Args> iterator emplace(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void assign(size_type, const T &) ;
+ template<typename InpIt> void assign(InpIt, InpIt) ;
+ void splice(iterator, ThisType &) ;
+ void splice(const_iterator, ThisType &, const_iterator) ;
+ void splice(const_iterator, ThisType &, const_iterator, const_iterator) ;
+ void splice(const_iterator, ThisType &, const_iterator, const_iterator,
 size_type) ;
- void reverse() ;
- void remove(const T &) ;
- template<typename Pred> void remove_if(Pred) ;
- void unique() ;
- template<typename BinaryPredicate> void unique(BinaryPredicate) ;
- void merge(list< T, A > &) ;
+ void reverse() ;
+ void remove(const T &) ;
+ template<typename Pred> void remove_if(Pred) ;
+ void unique() ;
+ template<typename BinaryPredicate> void unique(BinaryPredicate) ;
+ void merge(list< T, A > &) ;
 template<typename StrictWeakOrdering>
- void merge(list &, StrictWeakOrdering) ;
- void sort() ;
- template<typename StrictWeakOrdering> void sort(StrictWeakOrdering) ;
+ void merge(list &, StrictWeakOrdering) ;
+ void sort() ;
+ template<typename StrictWeakOrdering> void sort(StrictWeakOrdering) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id510404"></a><h2>Description</h2>
+<a name="id492978"></a><h2>Description</h2>
A list is a doubly linked list. That is, it is a Sequence that supports both forward and backward traversal, and (amortized) constant time insertion and removal of elements at the beginning or the end, or in the middle. Lists have the important property that insertion and splicing do not invalidate iterators to list elements, and that even removal invalidates only the iterators that point to the elements that are removed. The ordering of iterators may be changed (that is, list<T>::iterator might have a different predecessor or successor after a list operation than it did before), but the iterators themselves will not be invalidated or made to point to different elements unless that invalidation or mutation is explicit. 
<div class="refsect2" lang="en">
-<a name="id510410"></a><h3>
+<a name="id492984"></a><h3>
<a name="boost.container.listtypes"></a><code class="computeroutput">list</code>
 public
 types</h3>
@@ -139,64 +139,64 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id510452"></a><h3>
+<a name="id493026"></a><h3>
<a name="boost.container.listconstruct-copy-destruct"></a><code class="computeroutput">list</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id307784-bb"></a>list(const allocator_type & a = A());</pre>
+<pre class="literallayout"><a name="id307706-bb"></a>list(const allocator_type & a = A());</pre>
Effects: Constructs a list taking the allocator as parameter.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout"><a name="id307812-bb"></a>list(size_type n);</pre>
+<pre class="literallayout"><a name="id307734-bb"></a>list(size_type n);</pre>
Effects: Constructs a list that will use a copy of allocator a and inserts n copies of value.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout"><a name="id307837-bb"></a>list(size_type n, const T & value, const A & a = A());</pre>
+<pre class="literallayout"><a name="id307759-bb"></a>list(size_type n, const T & value, const A & a = A());</pre>
Effects: Constructs a list that will use a copy of allocator a and inserts n copies of value.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout"><a name="id307874-bb"></a>list(const list & x);</pre>
+<pre class="literallayout"><a name="id307796-bb"></a>list(const list & x);</pre>
Effects: Copy constructs a list.
Postcondition: x == *this.
Throws: If allocator_type's default constructor or copy constructor throws.
Complexity: Linear to the elements x contains. 
</li>
<li>
-<pre class="literallayout"><a name="id307909-bb"></a>list(BOOST_MOVE_MACRO_RV_REF(list) x);</pre>
+<pre class="literallayout"><a name="id307831-bb"></a>list(list && x);</pre>
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">template<typename InpIt> <a name="id307938-bb"></a>list(InpIt first, InpIt last, const A & a = A());</pre>
+<pre class="literallayout">template<typename InpIt> <a name="id307858-bb"></a>list(InpIt first, InpIt last, const A & a = A());</pre>
Effects: Constructs a list that will use a copy of allocator a and inserts a copy of the range [first, last) in the list.
Throws: If allocator_type's default constructor or copy constructor throws or T's constructor taking an dereferenced InIt throws.
Complexity: Linear to the range [first, last). 
</li>
<li>
-<pre class="literallayout">list& <a name="id308001-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(ThisType) x);</pre>
+<pre class="literallayout">list& <a name="id307922-bb"></a>operator=(const ThisType & x);</pre>
Effects: Makes *this contain the same elements as x.
Postcondition: this->size() == x.size(). *this contains a copy of each of x's elements.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to the number of elements in x. 
</li>
<li>
-<pre class="literallayout">list& <a name="id308034-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(ThisType) mx);</pre>
+<pre class="literallayout">list& <a name="id307954-bb"></a>operator=(ThisType && mx);</pre>
Effects: Move assignment. All mx's values are transferred to *this.
Postcondition: x.empty(). *this contains a the elements x had before the function.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout"><a name="id307981-bb"></a>~list();</pre>
+<pre class="literallayout"><a name="id307902-bb"></a>~list();</pre>
Effects: Destroys the list. All stored values are destroyed and used memory is deallocated.
Throws: Nothing.
Complexity: Linear to the number of elements. 
@@ -204,197 +204,197 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id510787"></a><h3>
-<a name="id304268-bb"></a><code class="computeroutput">list</code> public member functions</h3>
+<a name="id493366"></a><h3>
+<a name="id304241-bb"></a><code class="computeroutput">list</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">allocator_type <a name="id304270-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id304244-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the internal allocator.
Throws: If allocator's copy constructor throws.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id304296-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id304302-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id304269-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id304275-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">void <a name="id304308-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id304281-bb"></a>clear() ;</pre>
Effects: Erases all the elements of the list.
Throws: Nothing.
Complexity: Linear to the number of elements in the list. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id304333-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id304306-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id304358-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id304331-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id304383-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id304356-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id304408-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id304382-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id304434-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id304407-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id304459-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id304432-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id304484-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id304457-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id304509-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id304482-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id304534-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id304508-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id304560-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id304533-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id304585-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id304558-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id304610-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id304583-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id304635-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id304608-bb"></a>empty() const;</pre>
Effects: Returns true if the list contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id304660-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id304634-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id304687-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id304660-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id304712-bb"></a>push_front(const T & x) ;</pre>
+<pre class="literallayout">void <a name="id304685-bb"></a>push_front(const T & x) ;</pre>
Effects: Inserts a copy of t in the beginning of the list.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id304743-bb"></a>push_front(BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">void <a name="id304716-bb"></a>push_front(T && x) ;</pre>
Effects: Constructs a new element in the beginning of the list and moves the resources of t to this new element.
Throws: If memory allocation throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id304773-bb"></a>push_back(const T & x) ;</pre>
+<pre class="literallayout">void <a name="id304746-bb"></a>push_back(const T & x) ;</pre>
Effects: Removes the last element from the list.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id304803-bb"></a>push_back(BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">void <a name="id304776-bb"></a>push_back(T && x) ;</pre>
Effects: Removes the first element from the list.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id304833-bb"></a>pop_front() ;</pre>
+<pre class="literallayout">void <a name="id304806-bb"></a>pop_front() ;</pre>
Effects: Removes the first element from the list.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id304858-bb"></a>pop_back() ;</pre>
+<pre class="literallayout">void <a name="id304832-bb"></a>pop_back() ;</pre>
Effects: Removes the last element from the list.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">reference <a name="id304884-bb"></a>front() ;</pre>
+<pre class="literallayout">reference <a name="id304857-bb"></a>front() ;</pre>
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id304915-bb"></a>front() const;</pre>
+<pre class="literallayout">const_reference <a name="id304888-bb"></a>front() const;</pre>
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id304946-bb"></a>back() ;</pre>
+<pre class="literallayout">reference <a name="id304919-bb"></a>back() ;</pre>
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id304977-bb"></a>back() const;</pre>
+<pre class="literallayout">const_reference <a name="id304950-bb"></a>back() const;</pre>
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id305008-bb"></a>resize(size_type new_size, const T & x) ;</pre>
+<pre class="literallayout">void <a name="id304982-bb"></a>resize(size_type new_size, const T & x) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id305046-bb"></a>resize(size_type new_size) ;</pre>
+<pre class="literallayout">void <a name="id305019-bb"></a>resize(size_type new_size) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default constructed.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id305078-bb"></a>swap(ThisType & x) ;</pre>
+<pre class="literallayout">void <a name="id305051-bb"></a>swap(ThisType & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id305108-bb"></a>insert(const_iterator p, size_type n, const T & x) ;</pre>
+<pre class="literallayout">void <a name="id305081-bb"></a>insert(const_iterator p, size_type n, const T & x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Inserts n copies of x before p.
Throws: If memory allocation throws or T's copy constructor throws.
@@ -402,72 +402,72 @@
</li>
<li>
<pre class="literallayout">template<typename InpIt>
- void <a name="id305155-bb"></a>insert(const_iterator p, InpIt first, InpIt last) ;</pre>
+ void <a name="id305128-bb"></a>insert(const_iterator p, InpIt first, InpIt last) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of the [first, last) range before p.
Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws.
Complexity: Linear to std::distance [first, last). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id305206-bb"></a>insert(const_iterator position, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id305180-bb"></a>insert(const_iterator position, const T & x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of x before p.
Throws: If memory allocation throws or x's copy constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id305248-bb"></a>insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">iterator <a name="id305222-bb"></a>insert(const_iterator p, T && x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a new element before p with mx's resources.
Throws: If memory allocation throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">template<class... Args> void <a name="id305289-bb"></a>emplace_back(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> void <a name="id305262-bb"></a>emplace_back(Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the list.
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Constant 
</li>
<li>
-<pre class="literallayout">template<class... Args> void <a name="id305328-bb"></a>emplace_front(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> void <a name="id305301-bb"></a>emplace_front(Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the beginning of the list.
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Constant 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id305366-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id305339-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before p.
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Constant 
</li>
<li>
-<pre class="literallayout">iterator <a name="id305409-bb"></a>erase(const_iterator p) ;</pre>
+<pre class="literallayout">iterator <a name="id305382-bb"></a>erase(const_iterator p) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Erases the element at p p.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id305445-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id305418-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Requires: first and last must be valid iterator to elements in *this.
Effects: Erases the elements pointed by [first, last).
Throws: Nothing.
Complexity: Linear to the distance between first and last. 
</li>
<li>
-<pre class="literallayout">void <a name="id305487-bb"></a>assign(size_type n, const T & val) ;</pre>
+<pre class="literallayout">void <a name="id305460-bb"></a>assign(size_type n, const T & val) ;</pre>
Effects: Assigns the n copies of val to *this.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">template<typename InpIt> void <a name="id305523-bb"></a>assign(InpIt first, InpIt last) ;</pre>
+<pre class="literallayout">template<typename InpIt> void <a name="id305496-bb"></a>assign(InpIt first, InpIt last) ;</pre>
Effects: Assigns the the range [first, last) to *this.
Throws: If memory allocation throws or T's constructor from dereferencing InpIt throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">void <a name="id305564-bb"></a>splice(iterator p, ThisType & x) ;</pre>
+<pre class="literallayout">void <a name="id305537-bb"></a>splice(iterator p, ThisType & x) ;</pre>
Requires: p must point to an element contained by the list. x != *this
Effects: Transfers all the elements of list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -475,7 +475,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id305612-bb"></a>splice(const_iterator p, ThisType & x, const_iterator i) ;</pre>
+<pre class="literallayout">void <a name="id305585-bb"></a>splice(const_iterator p, ThisType & x, const_iterator i) ;</pre>
Requires: p must point to an element contained by this list. i must point to an element contained in list x.
Effects: Transfers the value pointed by i, from list x to this list, before the the element pointed by p. No destructors or copy constructors are called. If p == i or p == ++i, this function is a null operation.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -483,7 +483,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id305664-bb"></a>splice(const_iterator p, ThisType & x, const_iterator first,
+<pre class="literallayout">void <a name="id305637-bb"></a>splice(const_iterator p, ThisType & x, const_iterator first,
 const_iterator last) ;</pre>
Requires: p must point to an element contained by this list. first and last must point to elements contained in list x.
Effects: Transfers the range pointed by first and last from list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
@@ -492,7 +492,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id305720-bb"></a>splice(const_iterator p, ThisType & x, const_iterator first,
+<pre class="literallayout">void <a name="id305693-bb"></a>splice(const_iterator p, ThisType & x, const_iterator first,
 const_iterator last, size_type n) ;</pre>
Requires: p must point to an element contained by this list. first and last must point to elements contained in list x. n == std::distance(first, last)
Effects: Transfers the range pointed by first and last from list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
@@ -501,42 +501,42 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id307433-bb"></a>reverse() ;</pre>
+<pre class="literallayout">void <a name="id307354-bb"></a>reverse() ;</pre>
Effects: Reverses the order of elements in the list.
Throws: Nothing.
Complexity: This function is linear time.
Note: Iterators and references are not invalidated 
</li>
<li>
-<pre class="literallayout">void <a name="id307464-bb"></a>remove(const T & value) ;</pre>
+<pre class="literallayout">void <a name="id307386-bb"></a>remove(const T & value) ;</pre>
Effects: Removes all the elements that compare equal to value.
Throws: Nothing.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">template<typename Pred> void <a name="id307500-bb"></a>remove_if(Pred pred) ;</pre>
+<pre class="literallayout">template<typename Pred> void <a name="id307422-bb"></a>remove_if(Pred pred) ;</pre>
Effects: Removes all the elements for which a specified predicate is satisfied.
Throws: If pred throws.
Complexity: Linear time. It performs exactly size() calls to the predicate.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">void <a name="id307542-bb"></a>unique() ;</pre>
+<pre class="literallayout">void <a name="id307464-bb"></a>unique() ;</pre>
Effects: Removes adjacent duplicate elements or adjacent elements that are equal from the list.
Throws: Nothing.
Complexity: Linear time (size()-1 comparisons calls to pred()).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">template<typename BinaryPredicate> void <a name="id307573-bb"></a>unique(BinaryPredicate binary_pred) ;</pre>
+<pre class="literallayout">template<typename BinaryPredicate> void <a name="id307495-bb"></a>unique(BinaryPredicate binary_pred) ;</pre>
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list.
Throws: If pred throws.
Complexity: Linear time (size()-1 comparisons equality comparisons).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">void <a name="id307616-bb"></a>merge(list< T, A > & x) ;</pre>
+<pre class="literallayout">void <a name="id307538-bb"></a>merge(list< T, A > & x) ;</pre>
Requires: The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this according to std::less<value_type>. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
@@ -544,7 +544,7 @@
</li>
<li>
<pre class="literallayout">template<typename StrictWeakOrdering>
- void <a name="id307655-bb"></a>merge(list & x, StrictWeakOrdering comp) ;</pre>
+ void <a name="id307576-bb"></a>merge(list & x, StrictWeakOrdering comp) ;</pre>
Requires: p must be a comparison function that induces a strict weak ordering and both *this and x must be sorted according to that ordering The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
@@ -552,14 +552,14 @@
Note: Iterators and references to *this are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id307711-bb"></a>sort() ;</pre>
+<pre class="literallayout">void <a name="id307633-bb"></a>sort() ;</pre>
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.
Complexity: The number of comparisons is approximately N log N, where N is the list's size. 
</li>
<li>
-<pre class="literallayout">template<typename StrictWeakOrdering> void <a name="id307742-bb"></a>sort(StrictWeakOrdering comp) ;</pre>
+<pre class="literallayout">template<typename StrictWeakOrdering> void <a name="id307664-bb"></a>sort(StrictWeakOrdering comp) ;</pre>
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.

Modified: sandbox/move/libs/container/doc/html/boost/container/map.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/map.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/map.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -56,97 +56,95 @@
 typedef value_compare_impl <a name="boost.container.map.value_compare"></a>value_compare;

 // construct/copy/destruct
- map(const Pred & = Pred(), const allocator_type & = allocator_type());
+ map(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- map(InputIterator, InputIterator, const Pred & = Pred(),
+ map(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- map(ordered_unique_range_t, InputIterator, InputIterator,
+ map(ordered_unique_range_t, InputIterator, InputIterator,
 const Pred & = Pred(), const allocator_type & = allocator_type());
- map(const map< Key, T, Pred, Alloc > &);
- map(BOOST_MOVE_MACRO_RV_REF(map));
- map& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(map));
- map& operator=(BOOST_MOVE_MACRO_RV_REF(map));
+ map(const map< Key, T, Pred, Alloc > &);
+ map(map &&);
+ map& operator=(const map &);
+ map& operator=(map &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- T & operator[](const key_type &) ;
- T & operator[](BOOST_MOVE_MACRO_RV_REF(key_type)) ;
- T & at(const key_type &) ;
- const T & at(const key_type &) const;
- void swap(map &) ;
- std::pair< iterator, bool > insert(const value_type &) ;
- std::pair< iterator, bool > insert(const nonconst_value_type &) ;
- std::pair< iterator, bool >
- insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type)) ;
- std::pair< iterator, bool >
- insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type)) ;
- std::pair< iterator, bool > insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(iterator, const value_type &) ;
- iterator insert(iterator, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type)) ;
- iterator insert(iterator, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type)) ;
- iterator insert(iterator, const nonconst_value_type &) ;
- iterator insert(iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ T & operator[](const key_type &) ;
+ T & operator[](key_type &&) ;
+ T & at(const key_type &) ;
+ const T & at(const key_type &) const;
+ void swap(map &) ;
+ std::pair< iterator, bool > insert(const value_type &) ;
+ std::pair< iterator, bool > insert(const nonconst_value_type &) ;
+ std::pair< iterator, bool > insert(nonconst_value_type &&) ;
+ std::pair< iterator, bool > insert(nonconst_impl_value_type &&) ;
+ std::pair< iterator, bool > insert(value_type &&) ;
+ iterator insert(iterator, const value_type &) ;
+ iterator insert(iterator, nonconst_value_type &&) ;
+ iterator insert(iterator, nonconst_impl_value_type &&) ;
+ iterator insert(iterator, const nonconst_value_type &) ;
+ iterator insert(iterator, value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
+ equal_range(const key_type &) const;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id515918"></a><h2>Description</h2>
+<a name="id499592"></a><h2>Description</h2>
A map is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval of values of another type T based on the keys. The map class supports bidirectional iterators.
A map satisfies all of the requirements of a container and of a reversible 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>).
Alloc is the allocator to allocate the value_types (e.g. allocator< std::pair<const Key, T> > ). 
<div class="refsect2" lang="en">
-<a name="id515932"></a><h3>
+<a name="id499605"></a><h3>
<a name="boost.container.mapconstruct-copy-destruct"></a><code class="computeroutput">map</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id309852-bb"></a>map(const Pred & comp = Pred(), const allocator_type & a = allocator_type());</pre>
+<pre class="literallayout"><a name="id309781-bb"></a>map(const Pred & comp = Pred(), const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty map using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id309881-bb"></a>map(InputIterator first, InputIterator last, const Pred & comp = Pred(),
+ <a name="id309810-bb"></a>map(InputIterator first, InputIterator last, const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty map using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
Complexity: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id309925-bb"></a>map(ordered_unique_range_t, InputIterator first, InputIterator last,
+ <a name="id309854-bb"></a>map(ordered_unique_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty map using the specified comparison object and allocator, and inserts elements from the ordered unique range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -154,292 +152,288 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id309980-bb"></a>map(const map< Key, T, Pred, Alloc > & x);</pre>
+<pre class="literallayout"><a name="id309909-bb"></a>map(const map< Key, T, Pred, Alloc > & x);</pre>
Effects: Copy constructs a map.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id310003-bb"></a>map(BOOST_MOVE_MACRO_RV_REF(map) x);</pre>
+<pre class="literallayout"><a name="id309932-bb"></a>map(map && x);</pre>
Effects: Move constructs a map. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">map& <a name="id310033-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(map) x);</pre>
+<pre class="literallayout">map& <a name="id309961-bb"></a>operator=(const map & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">map& <a name="id310056-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(map) x);</pre>
+<pre class="literallayout">map& <a name="id309984-bb"></a>operator=(map && x);</pre>
Effects: this->swap(x.get()).
Complexity: Constant. 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id516193"></a><h3>
-<a name="id308413-bb"></a><code class="computeroutput">map</code> public member functions</h3>
+<a name="id499872"></a><h3>
+<a name="id308334-bb"></a><code class="computeroutput">map</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id308415-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id308336-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id308436-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id308356-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id308455-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id308376-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id308474-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id308480-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id308395-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id308401-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id308486-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id308407-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id308511-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id308432-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id308537-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id308457-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id308562-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id308482-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id308587-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id308508-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id308612-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id308533-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id308637-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id308558-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id308663-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id308583-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id308688-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id308608-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id308713-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id308634-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id308738-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id308659-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">T & <a name="id308763-bb"></a>operator[](const key_type & k) ;</pre>
+<pre class="literallayout">T & <a name="id308684-bb"></a>operator[](const key_type & k) ;</pre>
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.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">T & <a name="id308783-bb"></a>operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk) ;</pre>
+<pre class="literallayout">T & <a name="id308703-bb"></a>operator[](key_type && mk) ;</pre>
Effects: If there is no key equivalent to x in the map, inserts value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x), T()) into the map (the key is move-constructed)
Returns: A reference to the mapped_type corresponding to x in *this.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">T & <a name="id308802-bb"></a>at(const key_type & k) ;</pre>
+<pre class="literallayout">T & <a name="id308722-bb"></a>at(const key_type & k) ;</pre>
Returns: A 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. 
</li>
<li>
-<pre class="literallayout">const T & <a name="id308816-bb"></a>at(const key_type & k) const;</pre>
+<pre class="literallayout">const T & <a name="id308737-bb"></a>at(const key_type & k) const;</pre>
Returns: A 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. 
</li>
<li>
-<pre class="literallayout">void <a name="id308831-bb"></a>swap(map & x) ;</pre>
+<pre class="literallayout">void <a name="id308751-bb"></a>swap(map & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id308863-bb"></a>insert(const value_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id308784-bb"></a>insert(const value_type & x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id308893-bb"></a>insert(const nonconst_value_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id308814-bb"></a>insert(const nonconst_value_type & x) ;</pre>
Effects: Inserts a new value_type created from the pair 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. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool >
-<a name="id308923-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id308844-bb"></a>insert(nonconst_value_type && x) ;</pre>
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.
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. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool >
-<a name="id308953-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id308874-bb"></a>insert(nonconst_impl_value_type && x) ;</pre>
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.
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. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id308983-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id308904-bb"></a>insert(value_type && x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309013-bb"></a>insert(iterator position, const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id308934-bb"></a>insert(iterator position, const value_type & x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309048-bb"></a>insert(iterator position,
- BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id308968-bb"></a>insert(iterator position, nonconst_value_type && x) ;</pre>
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. 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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309083-bb"></a>insert(iterator position,
- BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id309003-bb"></a>insert(iterator position, nonconst_impl_value_type && x) ;</pre>
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. 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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309117-bb"></a>insert(iterator position, const nonconst_value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id309038-bb"></a>insert(iterator position, const nonconst_value_type & x) ;</pre>
Effects: Inserts a copy of 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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309152-bb"></a>insert(iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id309073-bb"></a>insert(iterator position, value_type && x) ;</pre>
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. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id309187-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id309108-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element.
Complexity: N log(size()+N) (N is the distance from i to j) 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id309228-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id309148-bb"></a>emplace(Args &&... args) ;</pre>
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 an equivalent key. 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. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id309266-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id309187-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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 an equivalent key. 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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309309-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id309230-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Amortized constant time 
</li>
<li>
-<pre class="literallayout">size_type <a name="id309339-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id309260-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: log(size()) + count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309369-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id309290-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: log(size())+N where N is the distance from first to last. 
</li>
<li>
-<pre class="literallayout">void <a name="id309405-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id309326-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309431-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id309351-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id309455-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id309375-bb"></a>find(const key_type & x) const;</pre>
Returns: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id309479-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id309399-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309503-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id309423-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id309527-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id309447-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id309551-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id309471-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id309575-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id309495-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id309599-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id309733-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id309828-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id309757-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>

Modified: sandbox/move/libs/container/doc/html/boost/container/multimap.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/multimap.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/multimap.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -56,84 +56,84 @@
 typedef value_compare_impl <a name="boost.container.multimap.value_compare"></a>value_compare;

 // construct/copy/destruct
- multimap(const Pred & = Pred(), const allocator_type & = allocator_type());
+ multimap(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- multimap(InputIterator, InputIterator, const Pred & = Pred(),
+ multimap(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- multimap(ordered_range_t, InputIterator, InputIterator,
+ multimap(ordered_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- multimap(const multimap< Key, T, Pred, Alloc > &);
- multimap(BOOST_MOVE_MACRO_RV_REF(multimap));
- multimap& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multimap));
- multimap& operator=(BOOST_MOVE_MACRO_RV_REF(multimap));
+ multimap(const multimap< Key, T, Pred, Alloc > &);
+ multimap(multimap &&);
+ multimap& operator=(const multimap &);
+ multimap& operator=(multimap &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(multimap &) ;
- iterator insert(const value_type &) ;
- iterator insert(const nonconst_value_type &) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type)) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type)) ;
- iterator insert(iterator, const value_type &) ;
- iterator insert(iterator, const nonconst_value_type &) ;
- iterator insert(iterator, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type)) ;
- iterator insert(iterator, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(multimap &) ;
+ iterator insert(const value_type &) ;
+ iterator insert(const nonconst_value_type &) ;
+ iterator insert(nonconst_value_type &&) ;
+ iterator insert(nonconst_impl_value_type &&) ;
+ iterator insert(iterator, const value_type &) ;
+ iterator insert(iterator, const nonconst_value_type &) ;
+ iterator insert(iterator, nonconst_value_type &&) ;
+ iterator insert(iterator, nonconst_impl_value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
+ equal_range(const key_type &) const;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id520111"></a><h2>Description</h2>
+<a name="id503770"></a><h2>Description</h2>
A multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. The multimap class supports bidirectional iterators.
A multimap satisfies all of the requirements of a container and of a reversible 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>).
Alloc is the allocator to allocate the value_types (e.g. allocator< std::pair<const Key, T> >). 
<div class="refsect2" lang="en">
-<a name="id520129"></a><h3>
+<a name="id503788"></a><h3>
<a name="boost.container.multimapconstruct-copy-destruct"></a><code class="computeroutput">multimap</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id311285-bb"></a>multimap(const Pred & comp = Pred(),
+<pre class="literallayout"><a name="id311211-bb"></a>multimap(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multimap using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id311314-bb"></a>multimap(InputIterator first, InputIterator last,
+ <a name="id311240-bb"></a>multimap(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
@@ -141,7 +141,7 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id311358-bb"></a>multimap(ordered_range_t ordered_range, InputIterator first,
+ <a name="id311285-bb"></a>multimap(ordered_range_t ordered_range, InputIterator first,
 InputIterator last, const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -149,254 +149,252 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id311414-bb"></a>multimap(const multimap< Key, T, Pred, Alloc > & x);</pre>
+<pre class="literallayout"><a name="id311341-bb"></a>multimap(const multimap< Key, T, Pred, Alloc > & x);</pre>
Effects: Copy constructs a multimap.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id311437-bb"></a>multimap(BOOST_MOVE_MACRO_RV_REF(multimap) x);</pre>
+<pre class="literallayout"><a name="id311364-bb"></a>multimap(multimap && x);</pre>
Effects: Move constructs a multimap. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">multimap& <a name="id311466-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multimap) x);</pre>
+<pre class="literallayout">multimap& <a name="id311391-bb"></a>operator=(const multimap & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">multimap& <a name="id311489-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(multimap) x);</pre>
+<pre class="literallayout">multimap& <a name="id311414-bb"></a>operator=(multimap && x);</pre>
Effects: this->swap(x.get()).
Complexity: Constant. 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id520390"></a><h3>
-<a name="id310207-bb"></a><code class="computeroutput">multimap</code> public member functions</h3>
+<a name="id504055"></a><h3>
+<a name="id310134-bb"></a><code class="computeroutput">multimap</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id310210-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id310136-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id310230-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id310157-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id310249-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id310176-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id310268-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id310274-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id310195-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id310201-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id310280-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id310207-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id310306-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id310232-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310331-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id310257-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id310356-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id310283-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id310381-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id310308-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id310406-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id310333-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id310432-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id310358-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id310457-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id310383-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id310482-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id310409-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id310507-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id310434-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id310532-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id310459-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id310558-bb"></a>swap(multimap & x) ;</pre>
+<pre class="literallayout">void <a name="id310484-bb"></a>swap(multimap & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310590-bb"></a>insert(const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id310517-bb"></a>insert(const value_type & x) ;</pre>
Effects: Inserts x and returns the iterator pointing to the newly inserted element.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310614-bb"></a>insert(const nonconst_value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id310541-bb"></a>insert(const nonconst_value_type & x) ;</pre>
Effects: Inserts a new value constructed from x and returns the iterator pointing to the newly inserted element.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310638-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id310565-bb"></a>insert(nonconst_value_type && x) ;</pre>
Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310662-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id310589-bb"></a>insert(nonconst_impl_value_type && x) ;</pre>
Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310686-bb"></a>insert(iterator position, const value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id310613-bb"></a>insert(iterator position, const value_type & x) ;</pre>
Effects: Inserts a copy of 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 in general, but amortized constant if t is inserted right before p. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310721-bb"></a>insert(iterator position, const nonconst_value_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id310647-bb"></a>insert(iterator position, const nonconst_value_type & x) ;</pre>
Effects: Inserts a new value 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 in general, but amortized constant if t is inserted right before p. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310756-bb"></a>insert(iterator position,
- BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id310682-bb"></a>insert(iterator position, nonconst_value_type && x) ;</pre>
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.
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310790-bb"></a>insert(iterator position,
- BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id310717-bb"></a>insert(iterator position, nonconst_impl_value_type && x) ;</pre>
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.
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. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id310825-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id310752-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) .
Complexity: N log(size()+N) (N is the distance from i to j) 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id310866-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id310793-bb"></a>emplace(Args &&... args) ;</pre>
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. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id310904-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id310831-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id310948-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id310874-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element pointed to by position.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Amortized constant time 
</li>
<li>
-<pre class="literallayout">size_type <a name="id310978-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id310904-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: log(size()) + count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id311008-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id310934-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: log(size())+N where N is the distance from first to last. 
</li>
<li>
-<pre class="literallayout">void <a name="id311044-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id310970-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id311069-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id310995-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id311093-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id311019-bb"></a>find(const key_type & x) const;</pre>
Returns: A const iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id311117-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id311043-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id311141-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id311067-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id311165-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id311091-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id311189-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id311115-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id311213-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id311139-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id311237-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id311163-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id311261-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id311187-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>

Modified: sandbox/move/libs/container/doc/html/boost/container/multiset.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/multiset.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/multiset.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -53,82 +53,82 @@
 typedef tree_t::stored_allocator_type <a name="boost.container.multiset.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- multiset(const Pred & = Pred(), const allocator_type & = allocator_type());
+ multiset(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- multiset(InputIterator, InputIterator, const Pred & = Pred(),
+ multiset(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- multiset(ordered_range_t, InputIterator, InputIterator,
+ multiset(ordered_range_t, InputIterator, InputIterator,
 const Pred & = Pred(),
 const allocator_type & = allocator_type());
- multiset(const multiset &);
- multiset(BOOST_MOVE_MACRO_RV_REF(multiset));
- multiset& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multiset));
- multiset& operator=(BOOST_MOVE_MACRO_RV_REF(multiset));
+ multiset(const multiset &);
+ multiset(multiset &&);
+ multiset& operator=(const multiset &);
+ multiset& operator=(multiset &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(multiset &) ;
- iterator insert(const T &) ;
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(multiset &) ;
+ iterator insert(const T &) ;
+ iterator insert(value_type &&) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
+ equal_range(const key_type &) const;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id530819"></a><h2>Description</h2>
+<a name="id514244"></a><h2>Description</h2>
A multiset is a kind of associative container that supports equivalent keys (possibly contains multiple copies of the same key value) and provides for fast retrieval of the keys themselves. Class multiset supports bidirectional iterators.
A multiset satisfies all of the requirements of a container and of a reversible container, and of an associative container). multiset also provides most operations described for duplicate keys. 
<div class="refsect2" lang="en">
-<a name="id530828"></a><h3>
+<a name="id514252"></a><h3>
<a name="boost.container.multisetconstruct-copy-destruct"></a><code class="computeroutput">multiset</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id316731-bb"></a>multiset(const Pred & comp = Pred(),
+<pre class="literallayout"><a name="id316653-bb"></a>multiset(const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multiset using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id316760-bb"></a>multiset(InputIterator first, InputIterator last,
+ <a name="id316681-bb"></a>multiset(InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multiset using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
@@ -136,7 +136,7 @@
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id316804-bb"></a>multiset(ordered_range_t ordered_range, InputIterator first,
+ <a name="id316726-bb"></a>multiset(ordered_range_t ordered_range, InputIterator first,
 InputIterator last, const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty multiset using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last ). This function is more efficient than the normal range creation for ordered ranges.
@@ -144,254 +144,254 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id316860-bb"></a>multiset(const multiset & x);</pre>
+<pre class="literallayout"><a name="id316782-bb"></a>multiset(const multiset & x);</pre>
Effects: Copy constructs a multiset.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id316883-bb"></a>multiset(BOOST_MOVE_MACRO_RV_REF(multiset) x);</pre>
+<pre class="literallayout"><a name="id316805-bb"></a>multiset(multiset && x);</pre>
Effects: Move constructs a multiset. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">multiset& <a name="id316912-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multiset) x);</pre>
+<pre class="literallayout">multiset& <a name="id316833-bb"></a>operator=(const multiset & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">multiset& <a name="id316935-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(multiset) x);</pre>
+<pre class="literallayout">multiset& <a name="id316855-bb"></a>operator=(multiset && x);</pre>
Effects: this->swap(x.get()).
Complexity: Constant. 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id531089"></a><h3>
-<a name="id314099-bb"></a><code class="computeroutput">multiset</code> public member functions</h3>
+<a name="id514519"></a><h3>
+<a name="id314021-bb"></a><code class="computeroutput">multiset</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id314102-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id314024-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id314122-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id314044-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id314141-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id314063-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id314160-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id314166-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id314082-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id314088-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id314172-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id314094-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id314198-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id314120-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id314223-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id314145-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id314248-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id314170-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id314273-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id314195-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id314298-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id314220-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id314324-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id314246-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id314349-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id314271-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id314374-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id314296-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id314399-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id314321-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id314424-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id314346-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id314450-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id314372-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id314475-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id314397-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id314500-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id314422-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id314525-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id314447-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id314550-bb"></a>swap(multiset & x) ;</pre>
+<pre class="literallayout">void <a name="id314472-bb"></a>swap(multiset & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id314583-bb"></a>insert(const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id314505-bb"></a>insert(const T & x) ;</pre>
Effects: Inserts x and returns the iterator pointing to the newly inserted element.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id314607-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id314529-bb"></a>insert(value_type && x) ;</pre>
Effects: Inserts a copy of x in the container.
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id314637-bb"></a>insert(const_iterator p, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id314559-bb"></a>insert(const_iterator p, const T & x) ;</pre>
Effects: Inserts a copy of 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 in general, but amortized constant if t is inserted right before p. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id314672-bb"></a>insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id314594-bb"></a>insert(const_iterator p, value_type && x) ;</pre>
Effects: Inserts a value 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 in general, but amortized constant if t is inserted right before p. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id314706-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id314628-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) .
Complexity: N log(size()+N) (N is the distance from i to j) 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id316318-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id316240-bb"></a>emplace(Args &&... args) ;</pre>
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. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id316350-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id316272-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id316394-bb"></a>erase(const_iterator p) ;</pre>
+<pre class="literallayout">iterator <a name="id316315-bb"></a>erase(const_iterator p) ;</pre>
Effects: Erases the element pointed to by p.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Amortized constant time 
</li>
<li>
-<pre class="literallayout">size_type <a name="id316424-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id316345-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: log(size()) + count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id316454-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id316375-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: log(size())+N where N is the distance from first to last. 
</li>
<li>
-<pre class="literallayout">void <a name="id316490-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id316411-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id316515-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id316437-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id316539-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id316461-bb"></a>find(const key_type & x) const;</pre>
Returns: A const iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id316563-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id316485-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id316587-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id316509-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id316611-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id316533-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id316635-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id316557-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id316659-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id316581-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id316683-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id316605-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id316707-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id316629-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>

Modified: sandbox/move/libs/container/doc/html/boost/container/ordered_range.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/ordered_range.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/ordered_range.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -6,7 +6,7 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.67.0">
<link rel="start" href="../../index.html" title="Chapter 1. Boost.Container">
<link rel="up" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp" title="Header <boost/container/container_fwd.hpp>">
-<link rel="prev" href="ordered_unique_range_im_id293881.html" title="Struct ordered_unique_range_impl_t">
+<link rel="prev" href="ordered_unique_range_im_id293621.html" title="Struct ordered_unique_range_impl_t">
<link rel="next" href="ordered_unique_range.html" title="Global ordered_unique_range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="ordered_unique_range_im_id293881.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="ordered_unique_range_im_id293621.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="refentry" lang="en">
<a name="boost.container.ordered_range"></a><div class="titlepage"></div>
@@ -33,7 +33,7 @@

static const ordered_range_t ordered_range;</pre></div>
<div class="refsect1" lang="en">
-<a name="id487207"></a><h2>Description</h2>
+<a name="id470823"></a><h2>Description</h2>
Value used to tag that the input range is guaranteed to be ordered 
</div>
</div>
@@ -47,7 +47,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="ordered_unique_range_im_id293881.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="ordered_unique_range_im_id293621.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/move/libs/container/doc/html/boost/container/ordered_range_impl_t.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/ordered_range_impl_t.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/ordered_range_impl_t.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -7,7 +7,7 @@
<link rel="start" href="../../index.html" title="Chapter 1. Boost.Container">
<link rel="up" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp" title="Header <boost/container/container_fwd.hpp>">
<link rel="prev" href="../../boost_container_reference.html" title="Boost.Container Reference">
-<link rel="next" href="ordered_unique_range_im_id293881.html" title="Struct ordered_unique_range_impl_t">
+<link rel="next" href="ordered_unique_range_im_id293621.html" title="Struct ordered_unique_range_impl_t">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../../boost_container_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range_im_id293881.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../../boost_container_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range_im_id293621.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="refentry" lang="en">
<a name="boost.container.ordered_range_impl_t"></a><div class="titlepage"></div>
@@ -35,7 +35,7 @@
struct ordered_range_impl_t {
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id487132"></a><h2>Description</h2>
+<a name="id470748"></a><h2>Description</h2>
Type used to tag that the input range is guaranteed to be ordered 
</div>
</div>
@@ -49,7 +49,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../../boost_container_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range_im_id293881.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../../boost_container_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_reference.html#header.boost.container.container_fwd_hpp"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="ordered_unique_range_im_id293621.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/move/libs/container/doc/html/boost/container/ordered_unique_range.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/ordered_unique_range.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/ordered_unique_range.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -33,7 +33,7 @@

static const ordered_unique_range_t ordered_unique_range;</pre></div>
<div class="refsect1" lang="en">
-<a name="id487242"></a><h2>Description</h2>
+<a name="id470858"></a><h2>Description</h2>
Value used to tag that the input range is guaranteed to be ordered and unique 
</div>
</div>

Modified: sandbox/move/libs/container/doc/html/boost/container/set.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/set.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/set.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -53,87 +53,87 @@
 typedef tree_t::stored_allocator_type <a name="boost.container.set.stored_allocator_type"></a>stored_allocator_type;

 // construct/copy/destruct
- set(const Pred & = Pred(), const allocator_type & = allocator_type());
+ set(const Pred & = Pred(), const allocator_type & = allocator_type());
 template<typename InputIterator>
- set(InputIterator, InputIterator, const Pred & = Pred(),
+ set(InputIterator, InputIterator, const Pred & = Pred(),
 const allocator_type & = allocator_type());
 template<typename InputIterator>
- set(ordered_unique_range_t, InputIterator, InputIterator,
+ set(ordered_unique_range_t, InputIterator, InputIterator,
 const Pred & = Pred(), const allocator_type & = allocator_type());
- set(const set &);
- set(BOOST_MOVE_MACRO_RV_REF(set));
- set& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(set));
- set& operator=(BOOST_MOVE_MACRO_RV_REF(set));
+ set(const set &);
+ set(set &&);
+ set& operator=(const set &);
+ set& operator=(set &&);

- // public member functions
- key_compare key_comp() const;
- value_compare value_comp() const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- bool empty() const;
- size_type size() const;
- size_type max_size() const;
- void swap(set &) ;
- std::pair< iterator, bool > insert(const T &) ;
- std::pair< iterator, bool > insert(BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- template<typename InputIterator> void insert(InputIterator, InputIterator) ;
- template<class... Args> iterator emplace(Args &&...) ;
- template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- size_type erase(const key_type &) ;
- iterator erase(const_iterator, const_iterator) ;
- void clear() ;
- iterator find(const key_type &) ;
- const_iterator find(const key_type &) const;
- size_type count(const key_type &) const;
- iterator lower_bound(const key_type &) ;
- const_iterator lower_bound(const key_type &) const;
- iterator upper_bound(const key_type &) ;
- const_iterator upper_bound(const key_type &) const;
- std::pair< iterator, iterator > equal_range(const key_type &) ;
+ // public member functions
+ key_compare key_comp() const;
+ value_compare value_comp() const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ bool empty() const;
+ size_type size() const;
+ size_type max_size() const;
+ void swap(set &) ;
+ std::pair< iterator, bool > insert(const T &) ;
+ std::pair< iterator, bool > insert(value_type &&) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ template<typename InputIterator> void insert(InputIterator, InputIterator) ;
+ template<class... Args> iterator emplace(Args &&...) ;
+ template<class... Args> iterator emplace_hint(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ size_type erase(const key_type &) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void clear() ;
+ iterator find(const key_type &) ;
+ const_iterator find(const key_type &) const;
+ size_type count(const key_type &) const;
+ iterator lower_bound(const key_type &) ;
+ const_iterator lower_bound(const key_type &) const;
+ iterator upper_bound(const key_type &) ;
+ const_iterator upper_bound(const key_type &) const;
+ std::pair< iterator, iterator > equal_range(const key_type &) ;
 std::pair< const_iterator, const_iterator >
- equal_range(const key_type &) const;
+ equal_range(const key_type &) const;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id525800"></a><h2>Description</h2>
+<a name="id510581"></a><h2>Description</h2>
A set is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval of the keys themselves. Class set supports bidirectional iterators.
A set satisfies all of the requirements of a container and of a reversible container , and of an associative container. A set also provides most operations described in for unique keys. 
<div class="refsect2" lang="en">
-<a name="id525809"></a><h3>
+<a name="id510589"></a><h3>
<a name="boost.container.setconstruct-copy-destruct"></a><code class="computeroutput">set</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id313774-bb"></a>set(const Pred & comp = Pred(), const allocator_type & a = allocator_type());</pre>
+<pre class="literallayout"><a name="id313698-bb"></a>set(const Pred & comp = Pred(), const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty set using the specified comparison object and allocator.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id313803-bb"></a>set(InputIterator first, InputIterator last, const Pred & comp = Pred(),
+ <a name="id313727-bb"></a>set(InputIterator first, InputIterator last, const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty set using the specified comparison object and allocator, and inserts elements from the range [first ,last ).
Complexity: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- <a name="id313847-bb"></a>set(ordered_unique_range_t, InputIterator first, InputIterator last,
+ <a name="id313772-bb"></a>set(ordered_unique_range_t, InputIterator first, InputIterator last,
 const Pred & comp = Pred(),
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs an empty set using the specified comparison object and allocator, and inserts elements from the ordered unique range [first ,last). This function is more efficient than the normal range creation for ordered ranges.
@@ -141,256 +141,256 @@
Complexity: Linear in N. 
</li>
<li>
-<pre class="literallayout"><a name="id313902-bb"></a>set(const set & x);</pre>
+<pre class="literallayout"><a name="id313827-bb"></a>set(const set & x);</pre>
Effects: Copy constructs a set.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout"><a name="id313925-bb"></a>set(BOOST_MOVE_MACRO_RV_REF(set) x);</pre>
+<pre class="literallayout"><a name="id313850-bb"></a>set(set && x);</pre>
Effects: Move constructs a set. Constructs *this using x's resources.
Complexity: Construct.
Postcondition: x is emptied. 
</li>
<li>
-<pre class="literallayout">set& <a name="id313955-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(set) x);</pre>
+<pre class="literallayout">set& <a name="id313878-bb"></a>operator=(const set & x);</pre>
Effects: Makes *this a copy of x.
Complexity: Linear in x.size(). 
</li>
<li>
-<pre class="literallayout">set& <a name="id313978-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(set) x);</pre>
+<pre class="literallayout">set& <a name="id313901-bb"></a>operator=(set && x);</pre>
Effects: this->swap(x.get()).
Complexity: Constant. 
</li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id526070"></a><h3>
-<a name="id312701-bb"></a><code class="computeroutput">set</code> public member functions</h3>
+<a name="id510856"></a><h3>
+<a name="id312626-bb"></a><code class="computeroutput">set</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">key_compare <a name="id312704-bb"></a>key_comp() const;</pre>
+<pre class="literallayout">key_compare <a name="id312628-bb"></a>key_comp() const;</pre>
Effects: Returns the comparison object out of which a was constructed.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">value_compare <a name="id312724-bb"></a>value_comp() const;</pre>
+<pre class="literallayout">value_compare <a name="id312648-bb"></a>value_comp() const;</pre>
Effects: Returns an object of value_compare constructed out of the comparison object.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id312743-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id312668-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the Allocator that was passed to the object's constructor.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id312762-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id312768-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id312687-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id312693-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">iterator <a name="id312774-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id312699-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id312800-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id312724-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id312825-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id312749-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id312850-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id312774-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id312875-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id312800-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id312900-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id312825-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id312926-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id312850-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id312951-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id312875-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id312976-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id312900-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id313001-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id312926-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id313026-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id312951-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id313052-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id312976-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id313077-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id313001-bb"></a>empty() const;</pre>
Effects: Returns true if the container contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id313102-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id313026-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id313127-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id313052-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id313152-bb"></a>swap(set & x) ;</pre>
+<pre class="literallayout">void <a name="id313077-bb"></a>swap(set & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id313185-bb"></a>insert(const T & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id313109-bb"></a>insert(const T & x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, bool > <a name="id313215-bb"></a>insert(BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">std::pair< iterator, bool > <a name="id313139-bb"></a>insert(value_type && x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313245-bb"></a>insert(const_iterator p, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id313169-bb"></a>insert(const_iterator p, const T & x) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313280-bb"></a>insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id313204-bb"></a>insert(const_iterator p, value_type && x) ;</pre>
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. 
</li>
<li>
<pre class="literallayout">template<typename InputIterator>
- void <a name="id313314-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
+ void <a name="id313239-bb"></a>insert(InputIterator first, InputIterator last) ;</pre>
Requires: i, j are not iterators into *this.
Effects: inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element.
Complexity: N log(size()+N) (N is the distance from i to j) 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id313355-bb"></a>emplace(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id313280-bb"></a>emplace(Args &&... args) ;</pre>
Effects: Inserts an object of type T 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 newly inserted element.
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Logarithmic. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id313394-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
+ iterator <a name="id313318-bb"></a>emplace_hint(const_iterator hint, Args &&... args) ;</pre>
Effects: Inserts an object of type T 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 should start to search.
Returns: An iterator pointing to the element with key equivalent to the key of x.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313437-bb"></a>erase(const_iterator p) ;</pre>
+<pre class="literallayout">iterator <a name="id313361-bb"></a>erase(const_iterator p) ;</pre>
Effects: Erases the element pointed to by p.
Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().
Complexity: Amortized constant time 
</li>
<li>
-<pre class="literallayout">size_type <a name="id313467-bb"></a>erase(const key_type & x) ;</pre>
+<pre class="literallayout">size_type <a name="id313391-bb"></a>erase(const key_type & x) ;</pre>
Effects: Erases all elements in the container with key equivalent to x.
Returns: Returns the number of erased elements.
Complexity: log(size()) + count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313497-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id313421-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases all the elements in the range [first, last).
Returns: Returns last.
Complexity: log(size())+N where N is the distance from first to last. 
</li>
<li>
-<pre class="literallayout">void <a name="id313533-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id313457-bb"></a>clear() ;</pre>
Effects: erase(a.begin(),a.end()).
Postcondition: size() == 0.
Complexity: linear in size(). 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313558-bb"></a>find(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id313482-bb"></a>find(const key_type & x) ;</pre>
Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id313582-bb"></a>find(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id313506-bb"></a>find(const key_type & x) const;</pre>
Returns: A const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.
Complexity: Logarithmic. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id313606-bb"></a>count(const key_type & x) const;</pre>
+<pre class="literallayout">size_type <a name="id313530-bb"></a>count(const key_type & x) const;</pre>
Returns: The number of elements with key equivalent to x.
Complexity: log(size())+count(k) 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313630-bb"></a>lower_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id313554-bb"></a>lower_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id313654-bb"></a>lower_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id313578-bb"></a>lower_bound(const key_type & x) const;</pre>
Returns: A 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 
</li>
<li>
-<pre class="literallayout">iterator <a name="id313678-bb"></a>upper_bound(const key_type & x) ;</pre>
+<pre class="literallayout">iterator <a name="id313602-bb"></a>upper_bound(const key_type & x) ;</pre>
Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id313702-bb"></a>upper_bound(const key_type & x) const;</pre>
+<pre class="literallayout">const_iterator <a name="id313626-bb"></a>upper_bound(const key_type & x) const;</pre>
Returns: A const iterator pointing to the first element with key not less than x, or end() if such an element is not found.
Complexity: Logarithmic 
</li>
<li>
-<pre class="literallayout">std::pair< iterator, iterator > <a name="id313726-bb"></a>equal_range(const key_type & x) ;</pre>
+<pre class="literallayout">std::pair< iterator, iterator > <a name="id313650-bb"></a>equal_range(const key_type & x) ;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>
<li>
<pre class="literallayout">std::pair< const_iterator, const_iterator >
-<a name="id313750-bb"></a>equal_range(const key_type & x) const;</pre>
+<a name="id313674-bb"></a>equal_range(const key_type & x) const;</pre>
Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Complexity: Logarithmic 
</li>

Modified: sandbox/move/libs/container/doc/html/boost/container/slist.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/slist.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/slist.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -46,89 +46,89 @@
 typedef NodeAlloc <a name="boost.container.slist.stored_allocator_type"></a>stored_allocator_type; // The stored allocator type. 

 // construct/copy/destruct
- slist(const allocator_type & = allocator_type());
- slist(size_type);
- slist(size_type, const value_type &,
+ slist(const allocator_type & = allocator_type());
+ slist(size_type);
+ slist(size_type, const value_type &,
 const allocator_type & = allocator_type());
 template<typename InpIt>
- slist(InpIt, InpIt, const allocator_type & = allocator_type());
- slist(const slist &);
- slist(BOOST_MOVE_MACRO_RV_REF(slist));
- slist& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(slist));
- slist& operator=(BOOST_MOVE_MACRO_RV_REF(slist));
- ~slist();
+ slist(InpIt, InpIt, const allocator_type & = allocator_type());
+ slist(const slist &);
+ slist(slist &&);
+ slist& operator=(const slist &);
+ slist& operator=(slist &&);
+ ~slist();

- // public member functions
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- void assign(size_type, const T &) ;
- template<typename InpIt> void assign(InpIt, InpIt) ;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- iterator before_begin() ;
- const_iterator before_begin() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_iterator cbefore_begin() const;
- size_type size() const;
- size_type max_size() const;
- bool empty() const;
- void swap(slist &) ;
- reference front() ;
- const_reference front() const;
- void push_front(const T &) ;
- void push_front(BOOST_MOVE_MACRO_RV_REF(T)) ;
- void pop_front() ;
- iterator previous(iterator) ;
- const_iterator previous(const_iterator) ;
- iterator insert_after(const_iterator, const T &) ;
- iterator insert_after(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- void insert_after(const_iterator, size_type, const value_type &) ;
- template<typename InIter> void insert_after(const_iterator, InIter, InIter) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(value_type)) ;
- void insert(const_iterator, size_type, const value_type &) ;
- template<typename InIter> void insert(const_iterator, InIter, InIter) ;
- template<class... Args> void emplace_front(Args &&...) ;
- template<class... Args> iterator emplace(const_iterator, Args &&...) ;
- template<class... Args> iterator emplace_after(const_iterator, Args &&...) ;
- iterator erase_after(const_iterator) ;
- iterator erase_after(const_iterator, const_iterator) ;
- iterator erase(const_iterator) ;
- iterator erase(const_iterator, const_iterator) ;
- void resize(size_type, const T &) ;
- void resize(size_type) ;
- void clear() ;
- void splice_after(const_iterator, slist &) ;
- void splice_after(const_iterator, slist &, const_iterator) ;
- void splice_after(const_iterator, slist &, const_iterator, const_iterator) ;
- void splice_after(const_iterator, slist &, const_iterator, const_iterator,
+ // public member functions
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ void assign(size_type, const T &) ;
+ template<typename InpIt> void assign(InpIt, InpIt) ;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ iterator before_begin() ;
+ const_iterator before_begin() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_iterator cbefore_begin() const;
+ size_type size() const;
+ size_type max_size() const;
+ bool empty() const;
+ void swap(slist &) ;
+ reference front() ;
+ const_reference front() const;
+ void push_front(const T &) ;
+ void push_front(T &&) ;
+ void pop_front() ;
+ iterator previous(iterator) ;
+ const_iterator previous(const_iterator) ;
+ iterator insert_after(const_iterator, const T &) ;
+ iterator insert_after(const_iterator, value_type &&) ;
+ void insert_after(const_iterator, size_type, const value_type &) ;
+ template<typename InIter> void insert_after(const_iterator, InIter, InIter) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, value_type &&) ;
+ void insert(const_iterator, size_type, const value_type &) ;
+ template<typename InIter> void insert(const_iterator, InIter, InIter) ;
+ template<class... Args> void emplace_front(Args &&...) ;
+ template<class... Args> iterator emplace(const_iterator, Args &&...) ;
+ template<class... Args> iterator emplace_after(const_iterator, Args &&...) ;
+ iterator erase_after(const_iterator) ;
+ iterator erase_after(const_iterator, const_iterator) ;
+ iterator erase(const_iterator) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void resize(size_type, const T &) ;
+ void resize(size_type) ;
+ void clear() ;
+ void splice_after(const_iterator, slist &) ;
+ void splice_after(const_iterator, slist &, const_iterator) ;
+ void splice_after(const_iterator, slist &, const_iterator, const_iterator) ;
+ void splice_after(const_iterator, slist &, const_iterator, const_iterator,
 size_type) ;
- void splice(const_iterator, ThisType &) ;
- void splice(const_iterator, slist &, const_iterator) ;
- void splice(const_iterator, slist &, const_iterator, const_iterator) ;
- void reverse() ;
- void remove(const T &) ;
- template<typename Pred> void remove_if(Pred) ;
- void unique() ;
- template<typename Pred> void unique(Pred) ;
- void merge(slist &) ;
+ void splice(const_iterator, ThisType &) ;
+ void splice(const_iterator, slist &, const_iterator) ;
+ void splice(const_iterator, slist &, const_iterator, const_iterator) ;
+ void reverse() ;
+ void remove(const T &) ;
+ template<typename Pred> void remove_if(Pred) ;
+ void unique() ;
+ template<typename Pred> void unique(Pred) ;
+ void merge(slist &) ;
 template<typename StrictWeakOrdering>
- void merge(slist &, StrictWeakOrdering) ;
- void sort() ;
- template<typename StrictWeakOrdering> void sort(StrictWeakOrdering) ;
+ void merge(slist &, StrictWeakOrdering) ;
+ void sort() ;
+ template<typename StrictWeakOrdering> void sort(StrictWeakOrdering) ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id534496"></a><h2>Description</h2>
+<a name="id518203"></a><h2>Description</h2>
An slist is a singly linked list: a list where each element is linked to the next element, but not to the previous element. That is, it is a Sequence that supports forward but not backward traversal, and (amortized) constant time insertion and removal of elements. Slists, like lists, have the important property that insertion and splicing do not invalidate iterators to list elements, and that even removal invalidates only the iterators that point to the elements that are removed. The ordering of iterators may be changed (that is, slist<T>::iterator might have a different predecessor or successor after a list operation than it did before), but the iterators themselves will not be invalidated or made to point to different elements unless that invalidation or mutation is explicit.
The main difference between slist and list is that list's iterators are bidirectional iterators, while slist's iterators are forward iterators. This means that slist is less versatile than list; frequently, however, bidirectional iterators are unnecessary. You should usually use slist unless you actually need the extra functionality of list, because singly linked lists are smaller and faster than double linked lists.
Important performance note: like every other Sequence, slist defines the member functions insert and erase. Using these member functions carelessly, however, can result in disastrously slow programs. The problem is that insert's first argument is an iterator p, and that it inserts the new element(s) before p. This means that insert must find the iterator just before p; this is a constant-time operation for list, since list has bidirectional iterators, but for slist it must find that iterator by traversing the list from the beginning up to p. In other words: insert and erase are slow operations anywhere but near the beginning of the slist.
Slist provides the member functions insert_after and erase_after, which are constant time operations: you should always use insert_after and erase_after whenever possible. If you find that insert_after and erase_after aren't adequate for your 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. 
<div class="refsect2" lang="en">
-<a name="id534509"></a><h3>
+<a name="id518217"></a><h3>
<a name="boost.container.slisttypes"></a><code class="computeroutput">slist</code>
 public
 types</h3>
@@ -139,20 +139,20 @@
</li></ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id534537"></a><h3>
+<a name="id518244"></a><h3>
<a name="boost.container.slistconstruct-copy-destruct"></a><code class="computeroutput">slist</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id319763-bb"></a>slist(const allocator_type & a = allocator_type());</pre>
+<pre class="literallayout"><a name="id319683-bb"></a>slist(const allocator_type & a = allocator_type());</pre>
Effects: Constructs a list taking the allocator as parameter.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
-<li><pre class="literallayout"><a name="id319791-bb"></a>slist(size_type n);</pre></li>
+<li><pre class="literallayout"><a name="id319710-bb"></a>slist(size_type n);</pre></li>
<li>
-<pre class="literallayout"><a name="id319797-bb"></a>slist(size_type n, const value_type & x,
+<pre class="literallayout"><a name="id319716-bb"></a>slist(size_type n, const value_type & x,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a list that will use a copy of allocator a and inserts n copies of value.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
@@ -160,40 +160,40 @@
</li>
<li>
<pre class="literallayout">template<typename InpIt>
- <a name="id319834-bb"></a>slist(InpIt first, InpIt last, const allocator_type & a = allocator_type());</pre>
+ <a name="id319754-bb"></a>slist(InpIt first, InpIt last, const allocator_type & a = allocator_type());</pre>
Effects: Constructs a list that will use a copy of allocator a and inserts a copy of the range [first, last) in the list.
Throws: If allocator_type's default constructor or copy constructor throws or T's constructor taking an dereferenced InIt throws.
Complexity: Linear to the range [first, last). 
</li>
<li>
-<pre class="literallayout"><a name="id319877-bb"></a>slist(const slist & x);</pre>
+<pre class="literallayout"><a name="id319797-bb"></a>slist(const slist & x);</pre>
Effects: Copy constructs a list.
Postcondition: x == *this.
Throws: If allocator_type's default constructor or copy constructor throws.
Complexity: Linear to the elements x contains. 
</li>
<li>
-<pre class="literallayout"><a name="id319912-bb"></a>slist(BOOST_MOVE_MACRO_RV_REF(slist) x);</pre>
+<pre class="literallayout"><a name="id319832-bb"></a>slist(slist && x);</pre>
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">slist& <a name="id319941-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(slist) x);</pre>
+<pre class="literallayout">slist& <a name="id319859-bb"></a>operator=(const slist & x);</pre>
Effects: Makes *this contain the same elements as x.
Postcondition: this->size() == x.size(). *this contains a copy of each of x's elements.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to the number of elements in x. 
</li>
<li>
-<pre class="literallayout">slist& <a name="id319977-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(slist) mx);</pre>
+<pre class="literallayout">slist& <a name="id319895-bb"></a>operator=(slist && mx);</pre>
Effects: Makes *this contain the same elements as x.
Postcondition: this->size() == x.size(). *this contains a copy of each of x's elements.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to the number of elements in x. 
</li>
<li>
-<pre class="literallayout"><a name="id320013-bb"></a>~slist();</pre>
+<pre class="literallayout"><a name="id319930-bb"></a>~slist();</pre>
Effects: Destroys the list. All stored values are destroyed and used memory is deallocated.
Throws: Nothing.
Complexity: Linear to the number of elements. 
@@ -201,153 +201,153 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id534863"></a><h3>
-<a name="id317536-bb"></a><code class="computeroutput">slist</code> public member functions</h3>
+<a name="id518575"></a><h3>
+<a name="id317455-bb"></a><code class="computeroutput">slist</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">allocator_type <a name="id317538-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id317458-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the internal allocator.
Throws: If allocator's copy constructor throws.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id317564-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id317570-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id317483-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id317489-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">void <a name="id317576-bb"></a>assign(size_type n, const T & val) ;</pre>
+<pre class="literallayout">void <a name="id317495-bb"></a>assign(size_type n, const T & val) ;</pre>
Effects: Assigns the n copies of val to *this.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">template<typename InpIt> void <a name="id317612-bb"></a>assign(InpIt first, InpIt last) ;</pre>
+<pre class="literallayout">template<typename InpIt> void <a name="id317531-bb"></a>assign(InpIt first, InpIt last) ;</pre>
Effects: Assigns the range [first, last) to *this.
Throws: If memory allocation throws or T's constructor from dereferencing InpIt throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id317652-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id317572-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317678-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317597-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id317703-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id317622-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317728-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317647-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id317753-bb"></a>before_begin() ;</pre>
+<pre class="literallayout">iterator <a name="id317673-bb"></a>before_begin() ;</pre>
Effects: Returns a non-dereferenceable iterator that, when incremented, yields begin(). This iterator may be used as the argument toinsert_after, erase_after, etc.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317778-bb"></a>before_begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317698-bb"></a>before_begin() const;</pre>
Effects: Returns a non-dereferenceable const_iterator that, when incremented, yields begin(). This iterator may be used as the argument toinsert_after, erase_after, etc.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317804-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317723-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317829-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317748-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id317854-bb"></a>cbefore_begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id317773-bb"></a>cbefore_begin() const;</pre>
Effects: Returns a non-dereferenceable const_iterator that, when incremented, yields begin(). This iterator may be used as the argument toinsert_after, erase_after, etc.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id317879-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id317799-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id317906-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id317825-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the list.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id317931-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id317850-bb"></a>empty() const;</pre>
Effects: Returns true if the list contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id317956-bb"></a>swap(slist & x) ;</pre>
+<pre class="literallayout">void <a name="id317875-bb"></a>swap(slist & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Linear to the number of elements on *this and x. 
</li>
<li>
-<pre class="literallayout">reference <a name="id317988-bb"></a>front() ;</pre>
+<pre class="literallayout">reference <a name="id317908-bb"></a>front() ;</pre>
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id318020-bb"></a>front() const;</pre>
+<pre class="literallayout">const_reference <a name="id317939-bb"></a>front() const;</pre>
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">void <a name="id318051-bb"></a>push_front(const T & x) ;</pre>
+<pre class="literallayout">void <a name="id317970-bb"></a>push_front(const T & x) ;</pre>
Effects: Inserts a copy of t in the beginning of the list.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id318082-bb"></a>push_front(BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">void <a name="id318001-bb"></a>push_front(T && x) ;</pre>
Effects: Constructs a new element in the beginning of the list and moves the resources of t to this new element.
Throws: If memory allocation throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id318112-bb"></a>pop_front() ;</pre>
+<pre class="literallayout">void <a name="id318031-bb"></a>pop_front() ;</pre>
Effects: Removes the first element from the list.
Throws: Nothing.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318137-bb"></a>previous(iterator p) ;</pre>
+<pre class="literallayout">iterator <a name="id318057-bb"></a>previous(iterator p) ;</pre>
Returns: The iterator to the element before i in the sequence. Returns the end-iterator, if either i is the begin-iterator or the sequence is empty.
Throws: Nothing.
Complexity: Linear to the number of elements before i. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id318167-bb"></a>previous(const_iterator p) ;</pre>
+<pre class="literallayout">const_iterator <a name="id318087-bb"></a>previous(const_iterator p) ;</pre>
Returns: The const_iterator to the element before i in the sequence. Returns the end-const_iterator, if either i is the begin-const_iterator or the sequence is empty.
Throws: Nothing.
Complexity: Linear to the number of elements before i. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318197-bb"></a>insert_after(const_iterator prev_pos, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id318117-bb"></a>insert_after(const_iterator prev_pos, const T & x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Inserts a copy of the value after the p pointed by prev_p.
Returns: An iterator to the inserted element.
@@ -356,8 +356,7 @@
Note: Does not affect the validity of iterators and references of previous values. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318252-bb"></a>insert_after(const_iterator prev_pos,
- BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id318172-bb"></a>insert_after(const_iterator prev_pos, value_type && x) ;</pre>
Requires: prev_pos must be a valid iterator of *this.
Effects: Inserts a move constructed copy object from the value after the p pointed by prev_pos.
Returns: An iterator to the inserted element.
@@ -366,7 +365,7 @@
Note: Does not affect the validity of iterators and references of previous values. 
</li>
<li>
-<pre class="literallayout">void <a name="id318305-bb"></a>insert_after(const_iterator prev_pos, size_type n, const value_type & x) ;</pre>
+<pre class="literallayout">void <a name="id318225-bb"></a>insert_after(const_iterator prev_pos, size_type n, const value_type & x) ;</pre>
Requires: prev_pos must be a valid iterator of *this.
Effects: Inserts n copies of x after prev_pos.
Throws: If memory allocation throws or T's copy constructor throws.
@@ -375,7 +374,7 @@
</li>
<li>
<pre class="literallayout">template<typename InIter>
- void <a name="id318358-bb"></a>insert_after(const_iterator prev_pos, InIter first, InIter last) ;</pre>
+ void <a name="id318277-bb"></a>insert_after(const_iterator prev_pos, InIter first, InIter last) ;</pre>
Requires: prev_pos must be a valid iterator of *this.
Effects: Inserts the range pointed by [first, last) after the p prev_pos.
Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws.
@@ -383,21 +382,21 @@
Note: Does not affect the validity of iterators and references of previous values. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318416-bb"></a>insert(const_iterator position, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id318335-bb"></a>insert(const_iterator position, const T & x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of x before p.
Throws: If memory allocation throws or x's copy constructor throws.
Complexity: Linear to the elements before p. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318458-bb"></a>insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x) ;</pre>
+<pre class="literallayout">iterator <a name="id318377-bb"></a>insert(const_iterator p, value_type && x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a new element before p with mx's resources.
Throws: If memory allocation throws.
Complexity: Linear to the elements before p. 
</li>
<li>
-<pre class="literallayout">void <a name="id318537-bb"></a>insert(const_iterator p, size_type n, const value_type & x) ;</pre>
+<pre class="literallayout">void <a name="id318456-bb"></a>insert(const_iterator p, size_type n, const value_type & x) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Inserts n copies of x before p.
Throws: If memory allocation throws or T's copy constructor throws.
@@ -405,33 +404,33 @@
</li>
<li>
<pre class="literallayout">template<typename InIter>
- void <a name="id318584-bb"></a>insert(const_iterator p, InIter first, InIter last) ;</pre>
+ void <a name="id318503-bb"></a>insert(const_iterator p, InIter first, InIter last) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of the [first, last) range before p.
Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws.
Complexity: Linear to std::distance [first, last) plus linear to the elements before p. 
</li>
<li>
-<pre class="literallayout">template<class... Args> void <a name="id318635-bb"></a>emplace_front(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> void <a name="id318555-bb"></a>emplace_front(Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the front of the list
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">template<class... Args> iterator <a name="id318675-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> iterator <a name="id318594-bb"></a>emplace(const_iterator p, Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before p
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Linear to the elements before p 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id318718-bb"></a>emplace_after(const_iterator prev, Args &&... args) ;</pre>
+ iterator <a name="id318638-bb"></a>emplace_after(const_iterator prev, Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... after prev
Throws: If memory allocation throws or T's in-place constructor throws.
Complexity: Constant 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318761-bb"></a>erase_after(const_iterator prev_pos) ;</pre>
+<pre class="literallayout">iterator <a name="id318681-bb"></a>erase_after(const_iterator prev_pos) ;</pre>
Effects: Erases the element after the element pointed by prev_pos of the list.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
@@ -439,7 +438,7 @@
Note: Does not invalidate iterators or references to non erased elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318803-bb"></a>erase_after(const_iterator before_first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id318723-bb"></a>erase_after(const_iterator before_first, const_iterator last) ;</pre>
Effects: Erases the range (before_first, last) from the list.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
@@ -447,39 +446,39 @@
Note: Does not invalidate iterators or references to non erased elements. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318850-bb"></a>erase(const_iterator p) ;</pre>
+<pre class="literallayout">iterator <a name="id318770-bb"></a>erase(const_iterator p) ;</pre>
Requires: p must be a valid iterator of *this.
Effects: Erases the element at p p.
Throws: Nothing.
Complexity: Linear to the number of elements before p. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id318886-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id318806-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Requires: first and last must be valid iterator to elements in *this.
Effects: Erases the elements pointed by [first, last).
Throws: Nothing.
Complexity: Linear to the distance between first and last plus linear to the elements before first. 
</li>
<li>
-<pre class="literallayout">void <a name="id318928-bb"></a>resize(size_type new_size, const T & x) ;</pre>
+<pre class="literallayout">void <a name="id318848-bb"></a>resize(size_type new_size, const T & x) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id318965-bb"></a>resize(size_type new_size) ;</pre>
+<pre class="literallayout">void <a name="id318885-bb"></a>resize(size_type new_size) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default constructed.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id318998-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id318917-bb"></a>clear() ;</pre>
Effects: Erases all the elements of the list.
Throws: Nothing.
Complexity: Linear to the number of elements in the list. 
</li>
<li>
-<pre class="literallayout">void <a name="id319023-bb"></a>splice_after(const_iterator prev_pos, slist & x) ;</pre>
+<pre class="literallayout">void <a name="id318942-bb"></a>splice_after(const_iterator prev_pos, slist & x) ;</pre>
Requires: p must point to an element contained by the list. x != *this
Effects: Transfers all the elements of list x to this list, after the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -487,7 +486,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319073-bb"></a>splice_after(const_iterator prev_pos, slist & x, const_iterator prev) ;</pre>
+<pre class="literallayout">void <a name="id318993-bb"></a>splice_after(const_iterator prev_pos, slist & x, const_iterator prev) ;</pre>
Requires: prev_pos must be a valid iterator of this. i must point to an element contained in list x.
Effects: Transfers the value pointed by i, from list x to this list, after the element pointed by prev_pos. If prev_pos == prev or prev_pos == ++prev, this function is a null operation.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -495,7 +494,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319127-bb"></a>splice_after(const_iterator prev_pos, slist & x,
+<pre class="literallayout">void <a name="id319047-bb"></a>splice_after(const_iterator prev_pos, slist & x,
 const_iterator before_first, const_iterator before_last) ;</pre>
Requires: prev_pos must be a valid iterator of this. before_first and before_last must be valid iterators of x. prev_pos must not be contained in [before_first, before_last) range.
Effects: Transfers the range [before_first + 1, before_last + 1) from list x to this list, after the element pointed by prev_pos.
@@ -504,7 +503,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319186-bb"></a>splice_after(const_iterator prev_pos, slist & x,
+<pre class="literallayout">void <a name="id319106-bb"></a>splice_after(const_iterator prev_pos, slist & x,
 const_iterator before_first, const_iterator before_last,
 size_type n) ;</pre>
Requires: prev_pos must be a valid iterator of this. before_first and before_last must be valid iterators of x. prev_pos must not be contained in [before_first, before_last) range. n == std::distance(before_first, before_last)
@@ -514,7 +513,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319250-bb"></a>splice(const_iterator p, ThisType & x) ;</pre>
+<pre class="literallayout">void <a name="id319169-bb"></a>splice(const_iterator p, ThisType & x) ;</pre>
Requires: p must point to an element contained by the list. x != *this
Effects: Transfers all the elements of list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -522,7 +521,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319299-bb"></a>splice(const_iterator p, slist & x, const_iterator i) ;</pre>
+<pre class="literallayout">void <a name="id319218-bb"></a>splice(const_iterator p, slist & x, const_iterator i) ;</pre>
Requires: p must point to an element contained by this list. i must point to an element contained in list x.
Effects: Transfers the value pointed by i, from list x to this list, before the the element pointed by p. No destructors or copy constructors are called. If p == i or p == ++i, this function is a null operation.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
@@ -530,7 +529,7 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319353-bb"></a>splice(const_iterator p, slist & x, const_iterator first,
+<pre class="literallayout">void <a name="id319272-bb"></a>splice(const_iterator p, slist & x, const_iterator first,
 const_iterator last) ;</pre>
Requires: p must point to an element contained by this list. first and last must point to elements contained in list x.
Effects: Transfers the range pointed by first and last from list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
@@ -539,42 +538,42 @@
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319412-bb"></a>reverse() ;</pre>
+<pre class="literallayout">void <a name="id319331-bb"></a>reverse() ;</pre>
Effects: Reverses the order of elements in the list.
Throws: Nothing.
Complexity: This function is linear time.
Note: Iterators and references are not invalidated 
</li>
<li>
-<pre class="literallayout">void <a name="id319443-bb"></a>remove(const T & value) ;</pre>
+<pre class="literallayout">void <a name="id319362-bb"></a>remove(const T & value) ;</pre>
Effects: Removes all the elements that compare equal to value.
Throws: Nothing.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">template<typename Pred> void <a name="id319479-bb"></a>remove_if(Pred pred) ;</pre>
+<pre class="literallayout">template<typename Pred> void <a name="id319398-bb"></a>remove_if(Pred pred) ;</pre>
Effects: Removes all the elements for which a specified predicate is satisfied.
Throws: If pred throws.
Complexity: Linear time. It performs exactly size() calls to the predicate.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">void <a name="id319521-bb"></a>unique() ;</pre>
+<pre class="literallayout">void <a name="id319440-bb"></a>unique() ;</pre>
Effects: Removes adjacent duplicate elements or adjacent elements that are equal from the list.
Throws: Nothing.
Complexity: Linear time (size()-1 comparisons calls to pred()).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">template<typename Pred> void <a name="id319552-bb"></a>unique(Pred pred) ;</pre>
+<pre class="literallayout">template<typename Pred> void <a name="id319472-bb"></a>unique(Pred pred) ;</pre>
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list.
Throws: If pred throws.
Complexity: Linear time (size()-1 comparisons equality comparisons).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. 
</li>
<li>
-<pre class="literallayout">void <a name="id319595-bb"></a>merge(slist & x) ;</pre>
+<pre class="literallayout">void <a name="id319515-bb"></a>merge(slist & x) ;</pre>
Requires: The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this according to std::less<value_type>. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
@@ -582,7 +581,7 @@
</li>
<li>
<pre class="literallayout">template<typename StrictWeakOrdering>
- void <a name="id319634-bb"></a>merge(slist & x, StrictWeakOrdering comp) ;</pre>
+ void <a name="id319553-bb"></a>merge(slist & x, StrictWeakOrdering comp) ;</pre>
Requires: p must be a comparison function that induces a strict weak ordering and both *this and x must be sorted according to that ordering The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
@@ -590,14 +589,14 @@
Note: Iterators and references to *this are not invalidated. 
</li>
<li>
-<pre class="literallayout">void <a name="id319690-bb"></a>sort() ;</pre>
+<pre class="literallayout">void <a name="id319610-bb"></a>sort() ;</pre>
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.
Complexity: The number of comparisons is approximately N log N, where N is the list's size. 
</li>
<li>
-<pre class="literallayout">template<typename StrictWeakOrdering> void <a name="id319721-bb"></a>sort(StrictWeakOrdering comp) ;</pre>
+<pre class="literallayout">template<typename StrictWeakOrdering> void <a name="id319641-bb"></a>sort(StrictWeakOrdering comp) ;</pre>
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.

Modified: sandbox/move/libs/container/doc/html/boost/container/stable_vector.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/stable_vector.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/stable_vector.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -49,152 +49,152 @@
 typedef std::reverse_iterator< const_iterator > <a name="boost.container.stable_vector.const_reverse_iterator"></a>const_reverse_iterator;

 // construct/copy/destruct
- stable_vector(const Allocator & = Allocator());
- stable_vector(size_type);
- stable_vector(size_type, const T &, const Allocator & = Allocator());
+ stable_vector(const Allocator & = Allocator());
+ stable_vector(size_type);
+ stable_vector(size_type, const T &, const Allocator & = Allocator());
 template<typename InputIterator>
- stable_vector(InputIterator, InputIterator,
+ stable_vector(InputIterator, InputIterator,
 const Allocator & = Allocator());
- stable_vector(const stable_vector &);
- stable_vector(BOOST_MOVE_MACRO_RV_REF(stable_vector));
- stable_vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(stable_vector));
- stable_vector& operator=(BOOST_MOVE_MACRO_RV_REF(stable_vector));
- ~stable_vector();
+ stable_vector(const stable_vector &);
+ stable_vector(stable_vector &&);
+ stable_vector& operator=(const stable_vector &);
+ stable_vector& operator=(stable_vector &&);
+ ~stable_vector();

- // public member functions
- template<typename InputIterator> void assign(InputIterator, InputIterator) ;
- void assign(size_type, const T &) ;
- allocator_type get_allocator() const;
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- size_type size() const;
- size_type max_size() const;
- size_type capacity() const;
- bool empty() const;
- void resize(size_type, const T &) ;
- void resize(size_type) ;
- void reserve(size_type) ;
- reference operator[](size_type) ;
- const_reference operator[](size_type) const;
- const_reference at(size_type) const;
- reference at(size_type) ;
- reference front() ;
- const_reference front() const;
- reference back() ;
- const_reference back() const;
- void push_back(const T &) ;
- void push_back(BOOST_MOVE_MACRO_RV_REF(T)) ;
- void pop_back() ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(T)) ;
- void insert(const_iterator, size_type, const T &) ;
+ // public member functions
+ template<typename InputIterator> void assign(InputIterator, InputIterator) ;
+ void assign(size_type, const T &) ;
+ allocator_type get_allocator() const;
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ size_type size() const;
+ size_type max_size() const;
+ size_type capacity() const;
+ bool empty() const;
+ void resize(size_type, const T &) ;
+ void resize(size_type) ;
+ void reserve(size_type) ;
+ reference operator[](size_type) ;
+ const_reference operator[](size_type) const;
+ const_reference at(size_type) const;
+ reference at(size_type) ;
+ reference front() ;
+ const_reference front() const;
+ reference back() ;
+ const_reference back() const;
+ void push_back(const T &) ;
+ void push_back(T &&) ;
+ void pop_back() ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, T &&) ;
+ void insert(const_iterator, size_type, const T &) ;
 template<typename InputIterator>
- void insert(const_iterator, InputIterator, InputIterator) ;
- template<class... Args> void emplace_back(Args &&...) ;
- template<class... Args> iterator emplace(const_iterator, Args &&...) ;
- iterator erase(const_iterator) ;
- iterator erase(const_iterator, const_iterator) ;
- void swap(stable_vector &) ;
- void clear() ;
+ void insert(const_iterator, InputIterator, InputIterator) ;
+ template<class... Args> void emplace_back(Args &&...) ;
+ template<class... Args> iterator emplace(const_iterator, Args &&...) ;
+ iterator erase(const_iterator) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void swap(stable_vector &) ;
+ void clear() ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id541225"></a><h2>Description</h2>
+<a name="id525071"></a><h2>Description</h2>
Help taken from (Introducing stable_vector)
We present stable_vector, a fully STL-compliant stable container that provides most of the features of std::vector except element contiguity.
General properties: stable_vector satisfies all the requirements of a container, a reversible container and a sequence and provides all the optional operations present in std::vector. Like std::vector, iterators are random access. stable_vector does not provide element contiguity; in exchange for this absence, the container is stable, i.e. references and iterators to an element of a stable_vector remain valid as long as the element is not erased, and an iterator that has been assigned the return value of end() always remain valid until the destruction of the associated stable_vector.
Operation complexity: The big-O complexities of stable_vector operations match exactly those of std::vector. In general, insertion/deletion is constant time at the end of the sequence and linear elsewhere. Unlike std::vector, stable_vector does not internally perform any value_type destruction, copy or assignment operations other than those exactly corresponding to the insertion of new elements or deletion of stored elements, which can sometimes compensate in terms of performance for the extra burden of doing more pointer manipulation and an additional allocation per element.
Exception safety: As stable_vector does not internally copy elements around, some operations provide stronger exception safety guarantees than in std::vector: 
<div class="refsect2" lang="en">
-<a name="id541240"></a><h3>
+<a name="id525087"></a><h3>
<a name="boost.container.stable_vectorconstruct-copy-destruct"></a><code class="computeroutput">stable_vector</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
-<li><pre class="literallayout"><a name="id321272-bb"></a>stable_vector(const Allocator & al = Allocator());</pre></li>
-<li><pre class="literallayout"><a name="id321280-bb"></a>stable_vector(size_type n);</pre></li>
-<li><pre class="literallayout"><a name="id321286-bb"></a>stable_vector(size_type n, const T & t, const Allocator & al = Allocator());</pre></li>
+<li><pre class="literallayout"><a name="id321257-bb"></a>stable_vector(const Allocator & al = Allocator());</pre></li>
+<li><pre class="literallayout"><a name="id321266-bb"></a>stable_vector(size_type n);</pre></li>
+<li><pre class="literallayout"><a name="id321272-bb"></a>stable_vector(size_type n, const T & t, const Allocator & al = Allocator());</pre></li>
<li><pre class="literallayout">template<typename InputIterator>
- <a name="id321304-bb"></a>stable_vector(InputIterator first, InputIterator last,
+ <a name="id321290-bb"></a>stable_vector(InputIterator first, InputIterator last,
 const Allocator & al = Allocator());</pre></li>
-<li><pre class="literallayout"><a name="id321328-bb"></a>stable_vector(const stable_vector & x);</pre></li>
-<li><pre class="literallayout"><a name="id321338-bb"></a>stable_vector(BOOST_MOVE_MACRO_RV_REF(stable_vector) x);</pre></li>
-<li><pre class="literallayout">stable_vector& <a name="id321349-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(stable_vector) x);</pre></li>
-<li><pre class="literallayout">stable_vector& <a name="id321358-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(stable_vector) x);</pre></li>
-<li><pre class="literallayout"><a name="id321348-bb"></a>~stable_vector();</pre></li>
+<li><pre class="literallayout"><a name="id321314-bb"></a>stable_vector(const stable_vector & x);</pre></li>
+<li><pre class="literallayout"><a name="id321323-bb"></a>stable_vector(stable_vector && x);</pre></li>
+<li><pre class="literallayout">stable_vector& <a name="id321333-bb"></a>operator=(const stable_vector & x);</pre></li>
+<li><pre class="literallayout">stable_vector& <a name="id321342-bb"></a>operator=(stable_vector && x);</pre></li>
+<li><pre class="literallayout"><a name="id321332-bb"></a>~stable_vector();</pre></li>
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id541402"></a><h3>
-<a name="id320342-bb"></a><code class="computeroutput">stable_vector</code> public member functions</h3>
+<a name="id525254"></a><h3>
+<a name="id320259-bb"></a><code class="computeroutput">stable_vector</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li><pre class="literallayout">template<typename InputIterator>
- void <a name="id320344-bb"></a>assign(InputIterator first, InputIterator last) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320366-bb"></a>assign(size_type n, const T & t) ;</pre></li>
-<li><pre class="literallayout">allocator_type <a name="id320381-bb"></a>get_allocator() const;</pre></li>
-<li><pre class="literallayout">iterator <a name="id320387-bb"></a>begin() ;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id320393-bb"></a>begin() const;</pre></li>
-<li><pre class="literallayout">iterator <a name="id320399-bb"></a>end() ;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id320405-bb"></a>end() const;</pre></li>
-<li><pre class="literallayout">reverse_iterator <a name="id320411-bb"></a>rbegin() ;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id320417-bb"></a>rbegin() const;</pre></li>
-<li><pre class="literallayout">reverse_iterator <a name="id320423-bb"></a>rend() ;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id320429-bb"></a>rend() const;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id320435-bb"></a>cbegin() const;</pre></li>
-<li><pre class="literallayout">const_iterator <a name="id320441-bb"></a>cend() const;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id320447-bb"></a>crbegin() const;</pre></li>
-<li><pre class="literallayout">const_reverse_iterator <a name="id320453-bb"></a>crend() const;</pre></li>
-<li><pre class="literallayout">size_type <a name="id320459-bb"></a>size() const;</pre></li>
-<li><pre class="literallayout">size_type <a name="id320465-bb"></a>max_size() const;</pre></li>
-<li><pre class="literallayout">size_type <a name="id320471-bb"></a>capacity() const;</pre></li>
-<li><pre class="literallayout">bool <a name="id320477-bb"></a>empty() const;</pre></li>
-<li><pre class="literallayout">void <a name="id320483-bb"></a>resize(size_type n, const T & t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320499-bb"></a>resize(size_type n) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320510-bb"></a>reserve(size_type n) ;</pre></li>
-<li><pre class="literallayout">reference <a name="id320520-bb"></a>operator[](size_type n) ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id320531-bb"></a>operator[](size_type n) const;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id320542-bb"></a>at(size_type n) const;</pre></li>
-<li><pre class="literallayout">reference <a name="id320553-bb"></a>at(size_type n) ;</pre></li>
-<li><pre class="literallayout">reference <a name="id320564-bb"></a>front() ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id320570-bb"></a>front() const;</pre></li>
-<li><pre class="literallayout">reference <a name="id320576-bb"></a>back() ;</pre></li>
-<li><pre class="literallayout">const_reference <a name="id320582-bb"></a>back() const;</pre></li>
-<li><pre class="literallayout">void <a name="id320588-bb"></a>push_back(const T & x) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320598-bb"></a>push_back(BOOST_MOVE_MACRO_RV_REF(T) t) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320609-bb"></a>pop_back() ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id320615-bb"></a>insert(const_iterator position, const T & x) ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id320631-bb"></a>insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre></li>
-<li><pre class="literallayout">void <a name="id320646-bb"></a>insert(const_iterator position, size_type n, const T & t) ;</pre></li>
+ void <a name="id320261-bb"></a>assign(InputIterator first, InputIterator last) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320283-bb"></a>assign(size_type n, const T & t) ;</pre></li>
+<li><pre class="literallayout">allocator_type <a name="id320298-bb"></a>get_allocator() const;</pre></li>
+<li><pre class="literallayout">iterator <a name="id320304-bb"></a>begin() ;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id320310-bb"></a>begin() const;</pre></li>
+<li><pre class="literallayout">iterator <a name="id320316-bb"></a>end() ;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id320322-bb"></a>end() const;</pre></li>
+<li><pre class="literallayout">reverse_iterator <a name="id320328-bb"></a>rbegin() ;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id320334-bb"></a>rbegin() const;</pre></li>
+<li><pre class="literallayout">reverse_iterator <a name="id320340-bb"></a>rend() ;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id320346-bb"></a>rend() const;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id320352-bb"></a>cbegin() const;</pre></li>
+<li><pre class="literallayout">const_iterator <a name="id320358-bb"></a>cend() const;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id320364-bb"></a>crbegin() const;</pre></li>
+<li><pre class="literallayout">const_reverse_iterator <a name="id320370-bb"></a>crend() const;</pre></li>
+<li><pre class="literallayout">size_type <a name="id320376-bb"></a>size() const;</pre></li>
+<li><pre class="literallayout">size_type <a name="id320382-bb"></a>max_size() const;</pre></li>
+<li><pre class="literallayout">size_type <a name="id320388-bb"></a>capacity() const;</pre></li>
+<li><pre class="literallayout">bool <a name="id320394-bb"></a>empty() const;</pre></li>
+<li><pre class="literallayout">void <a name="id320400-bb"></a>resize(size_type n, const T & t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320416-bb"></a>resize(size_type n) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320427-bb"></a>reserve(size_type n) ;</pre></li>
+<li><pre class="literallayout">reference <a name="id320438-bb"></a>operator[](size_type n) ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id320448-bb"></a>operator[](size_type n) const;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id320459-bb"></a>at(size_type n) const;</pre></li>
+<li><pre class="literallayout">reference <a name="id320470-bb"></a>at(size_type n) ;</pre></li>
+<li><pre class="literallayout">reference <a name="id320481-bb"></a>front() ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id320487-bb"></a>front() const;</pre></li>
+<li><pre class="literallayout">reference <a name="id320493-bb"></a>back() ;</pre></li>
+<li><pre class="literallayout">const_reference <a name="id320499-bb"></a>back() const;</pre></li>
+<li><pre class="literallayout">void <a name="id320505-bb"></a>push_back(const T & x) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320516-bb"></a>push_back(T && t) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320526-bb"></a>pop_back() ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id320532-bb"></a>insert(const_iterator position, const T & x) ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id320548-bb"></a>insert(const_iterator position, T && x) ;</pre></li>
+<li><pre class="literallayout">void <a name="id320564-bb"></a>insert(const_iterator position, size_type n, const T & t) ;</pre></li>
<li><pre class="literallayout">template<typename InputIterator>
- void <a name="id320667-bb"></a>insert(const_iterator position, InputIterator first,
+ void <a name="id320584-bb"></a>insert(const_iterator position, InputIterator first,
 InputIterator last) ;</pre></li>
<li>
-<pre class="literallayout">template<class... Args> void <a name="id320693-bb"></a>emplace_back(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> void <a name="id320610-bb"></a>emplace_back(Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the vector.
Throws: If memory allocation throws or the in-place constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id321177-bb"></a>emplace(const_iterator position, Args &&... args) ;</pre>
+ iterator <a name="id321162-bb"></a>emplace(const_iterator position, Args &&... args) ;</pre>
Requires: position must be a valid iterator of *this.
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before position
Throws: If memory allocation throws or the in-place constructor throws.
Complexity: If position is end(), amortized constant time Linear time otherwise. 
</li>
-<li><pre class="literallayout">iterator <a name="id321226-bb"></a>erase(const_iterator position) ;</pre></li>
-<li><pre class="literallayout">iterator <a name="id321237-bb"></a>erase(const_iterator first, const_iterator last) ;</pre></li>
-<li><pre class="literallayout">void <a name="id321253-bb"></a>swap(stable_vector & x) ;</pre></li>
-<li><pre class="literallayout">void <a name="id321266-bb"></a>clear() ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id321212-bb"></a>erase(const_iterator position) ;</pre></li>
+<li><pre class="literallayout">iterator <a name="id321222-bb"></a>erase(const_iterator first, const_iterator last) ;</pre></li>
+<li><pre class="literallayout">void <a name="id321238-bb"></a>swap(stable_vector & x) ;</pre></li>
+<li><pre class="literallayout">void <a name="id321251-bb"></a>clear() ;</pre></li>
</ol></div>
</div>
</div>

Modified: sandbox/move/libs/container/doc/html/boost/container/string.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/string.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/string.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -34,7 +34,7 @@

typedef basic_string< char,std::char_traits< char >,std::allocator< char > > string;</pre></div>
<div class="refsect1" lang="en">
-<a name="id554841"></a><h2>Description</h2>
+<a name="id538658"></a><h2>Description</h2>
Typedef for a basic_string of narrow characters 
</div>
</div>

Modified: sandbox/move/libs/container/doc/html/boost/container/vector.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/vector.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/vector.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -49,72 +49,72 @@
 typedef allocator_type <a name="boost.container.vector.stored_allocator_type"></a>stored_allocator_type; // The stored allocator type. 

 // construct/copy/destruct
- vector(const A & = A());
- vector(size_type);
- vector(size_type, const T &, const allocator_type & = allocator_type());
- vector(const vector< T, A > &);
- vector(BOOST_MOVE_MACRO_RV_REF(vector));
+ vector(const A & = A());
+ vector(size_type);
+ vector(size_type, const T &, const allocator_type & = allocator_type());
+ vector(const vector< T, A > &);
+ vector(vector &&);
 template<typename InIt>
- vector(InIt, InIt, const allocator_type & = allocator_type());
- vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(vector));
- vector& operator=(BOOST_MOVE_MACRO_RV_REF(vector));
- ~vector();
+ vector(InIt, InIt, const allocator_type & = allocator_type());
+ vector& operator=(const vector &);
+ vector& operator=(vector &&);
+ ~vector();

- // public member functions
- iterator begin() ;
- const_iterator begin() const;
- iterator end() ;
- const_iterator end() const;
- reverse_iterator rbegin() ;
- const_reverse_iterator rbegin() const;
- reverse_iterator rend() ;
- const_reverse_iterator rend() const;
- const_iterator cbegin() const;
- const_iterator cend() const;
- const_reverse_iterator crbegin() const;
- const_reverse_iterator crend() const;
- reference front() ;
- const_reference front() const;
- reference back() ;
- const_reference back() const;
- pointer data() ;
- const_pointer data() const;
- size_type size() const;
- size_type max_size() const;
- size_type capacity() const;
- bool empty() const;
- reference operator[](size_type) ;
- const_reference operator[](size_type) const;
- reference at(size_type) ;
- const_reference at(size_type) const;
- allocator_type get_allocator() const;
- const stored_allocator_type & get_stored_allocator() const;
- stored_allocator_type & get_stored_allocator() ;
- void reserve(size_type) ;
- void assign(size_type, const value_type &) ;
- template<typename InIt> void assign(InIt, InIt) ;
- void push_back(const T &) ;
- void push_back(BOOST_MOVE_MACRO_RV_REF(T)) ;
- template<class... Args> void emplace_back(Args &&...) ;
- template<class... Args> iterator emplace(const_iterator, Args &&...) ;
- void swap(vector &) ;
- iterator insert(const_iterator, const T &) ;
- iterator insert(const_iterator, BOOST_MOVE_MACRO_RV_REF(T)) ;
- template<typename InIt> void insert(const_iterator, InIt, InIt) ;
- void insert(const_iterator, size_type, const T &) ;
- void pop_back() ;
- iterator erase(const_iterator) ;
- iterator erase(const_iterator, const_iterator) ;
- void resize(size_type, const T &) ;
- void resize(size_type) ;
- void clear() ;
- void shrink_to_fit() ;
+ // public member functions
+ iterator begin() ;
+ const_iterator begin() const;
+ iterator end() ;
+ const_iterator end() const;
+ reverse_iterator rbegin() ;
+ const_reverse_iterator rbegin() const;
+ reverse_iterator rend() ;
+ const_reverse_iterator rend() const;
+ const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_reverse_iterator crbegin() const;
+ const_reverse_iterator crend() const;
+ reference front() ;
+ const_reference front() const;
+ reference back() ;
+ const_reference back() const;
+ pointer data() ;
+ const_pointer data() const;
+ size_type size() const;
+ size_type max_size() const;
+ size_type capacity() const;
+ bool empty() const;
+ reference operator[](size_type) ;
+ const_reference operator[](size_type) const;
+ reference at(size_type) ;
+ const_reference at(size_type) const;
+ allocator_type get_allocator() const;
+ const stored_allocator_type & get_stored_allocator() const;
+ stored_allocator_type & get_stored_allocator() ;
+ void reserve(size_type) ;
+ void assign(size_type, const value_type &) ;
+ template<typename InIt> void assign(InIt, InIt) ;
+ void push_back(const T &) ;
+ void push_back(T &&) ;
+ template<class... Args> void emplace_back(Args &&...) ;
+ template<class... Args> iterator emplace(const_iterator, Args &&...) ;
+ void swap(vector &) ;
+ iterator insert(const_iterator, const T &) ;
+ iterator insert(const_iterator, T &&) ;
+ template<typename InIt> void insert(const_iterator, InIt, InIt) ;
+ void insert(const_iterator, size_type, const T &) ;
+ void pop_back() ;
+ iterator erase(const_iterator) ;
+ iterator erase(const_iterator, const_iterator) ;
+ void resize(size_type, const T &) ;
+ void resize(size_type) ;
+ void clear() ;
+ void shrink_to_fit() ;
};</pre></div>
<div class="refsect1" lang="en">
-<a name="id556071"></a><h2>Description</h2>
+<a name="id539892"></a><h2>Description</h2>
A vector is a sequence that supports random access to elements, constant time insertion and removal of elements at the end, and linear time insertion and removal of elements at the beginning or in the middle. The number of elements in a vector may vary dynamically; memory management is automatic. boost::container::vector is similar to std::vector but it's compatible with shared memory and memory mapped files. 
<div class="refsect2" lang="en">
-<a name="id556077"></a><h3>
+<a name="id539898"></a><h3>
<a name="boost.container.vectortypes"></a><code class="computeroutput">vector</code>
 public
 types</h3>
@@ -125,65 +125,65 @@
</li></ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id556105"></a><h3>
+<a name="id539926"></a><h3>
<a name="boost.container.vectorconstruct-copy-destruct"></a><code class="computeroutput">vector</code>
 public
 construct/copy/destruct</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout"><a name="id329374-bb"></a>vector(const A & a = A());</pre>
+<pre class="literallayout"><a name="id329411-bb"></a>vector(const A & a = A());</pre>
Effects: Constructs a vector taking the allocator as parameter.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout"><a name="id329403-bb"></a>vector(size_type n);</pre>
+<pre class="literallayout"><a name="id329440-bb"></a>vector(size_type n);</pre>
Effects: Constructs a vector that will use a copy of allocator a and inserts n default contructed values.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout"><a name="id329428-bb"></a>vector(size_type n, const T & value,
+<pre class="literallayout"><a name="id329465-bb"></a>vector(size_type n, const T & value,
 const allocator_type & a = allocator_type());</pre>
Effects: Constructs a vector that will use a copy of allocator a and inserts n copies of value.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout"><a name="id329465-bb"></a>vector(const vector< T, A > & x);</pre>
+<pre class="literallayout"><a name="id329502-bb"></a>vector(const vector< T, A > & x);</pre>
Effects: Copy constructs a vector.
Postcondition: x == *this.
Complexity: Linear to the elements x contains. 
</li>
<li>
-<pre class="literallayout"><a name="id329494-bb"></a>vector(BOOST_MOVE_MACRO_RV_REF(vector) mx);</pre>
+<pre class="literallayout"><a name="id329531-bb"></a>vector(vector && mx);</pre>
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant. 
</li>
<li>
<pre class="literallayout">template<typename InIt>
- <a name="id329523-bb"></a>vector(InIt first, InIt last, const allocator_type & a = allocator_type());</pre>
+ <a name="id329558-bb"></a>vector(InIt first, InIt last, const allocator_type & a = allocator_type());</pre>
Effects: Constructs a vector that will use a copy of allocator a and inserts a copy of the range [first, last) in the vector.
Throws: If allocator_type's default constructor or copy constructor throws or T's constructor taking an dereferenced InIt throws.
Complexity: Linear to the range [first, last). 
</li>
<li>
-<pre class="literallayout">vector& <a name="id329586-bb"></a>operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(vector) x);</pre>
+<pre class="literallayout">vector& <a name="id329622-bb"></a>operator=(const vector & x);</pre>
Effects: Makes *this contain the same elements as x.
Postcondition: this->size() == x.size(). *this contains a copy of each of x's elements.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to the number of elements in x. 
</li>
<li>
-<pre class="literallayout">vector& <a name="id329622-bb"></a>operator=(BOOST_MOVE_MACRO_RV_REF(vector) x);</pre>
+<pre class="literallayout">vector& <a name="id329658-bb"></a>operator=(vector && x);</pre>
Effects: Move assignment. All mx's values are transferred to *this.
Postcondition: x.empty(). *this contains a the elements x had before the function.
Throws: If allocator_type's copy constructor throws.
Complexity: Linear. 
</li>
<li>
-<pre class="literallayout"><a name="id329566-bb"></a>~vector();</pre>
+<pre class="literallayout"><a name="id329602-bb"></a>~vector();</pre>
Effects: Destroys the vector. All stored values are destroyed and used memory is deallocated.
Throws: Nothing.
Complexity: Linear to the number of elements. 
@@ -191,238 +191,238 @@
</ol></div>
</div>
<div class="refsect2" lang="en">
-<a name="id556444"></a><h3>
-<a name="id327941-bb"></a><code class="computeroutput">vector</code> public member functions</h3>
+<a name="id541780"></a><h3>
+<a name="id327978-bb"></a><code class="computeroutput">vector</code> public member functions</h3>
<div class="orderedlist"><ol type="1">
<li>
-<pre class="literallayout">iterator <a name="id327944-bb"></a>begin() ;</pre>
+<pre class="literallayout">iterator <a name="id327980-bb"></a>begin() ;</pre>
Effects: Returns an iterator to the first element contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id327969-bb"></a>begin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id328006-bb"></a>begin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id327994-bb"></a>end() ;</pre>
+<pre class="literallayout">iterator <a name="id328031-bb"></a>end() ;</pre>
Effects: Returns an iterator to the end of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id328019-bb"></a>end() const;</pre>
+<pre class="literallayout">const_iterator <a name="id328056-bb"></a>end() const;</pre>
Effects: Returns a const_iterator to the end of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id328044-bb"></a>rbegin() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id328081-bb"></a>rbegin() ;</pre>
Effects: Returns a reverse_iterator pointing to the beginning of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id328070-bb"></a>rbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id328106-bb"></a>rbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reverse_iterator <a name="id328095-bb"></a>rend() ;</pre>
+<pre class="literallayout">reverse_iterator <a name="id328132-bb"></a>rend() ;</pre>
Effects: Returns a reverse_iterator pointing to the end of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id328120-bb"></a>rend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id328157-bb"></a>rend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id328145-bb"></a>cbegin() const;</pre>
+<pre class="literallayout">const_iterator <a name="id328182-bb"></a>cbegin() const;</pre>
Effects: Returns a const_iterator to the first element contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_iterator <a name="id328170-bb"></a>cend() const;</pre>
+<pre class="literallayout">const_iterator <a name="id328207-bb"></a>cend() const;</pre>
Effects: Returns a const_iterator to the end of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id328196-bb"></a>crbegin() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id328232-bb"></a>crbegin() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reverse_iterator <a name="id328221-bb"></a>crend() const;</pre>
+<pre class="literallayout">const_reverse_iterator <a name="id328258-bb"></a>crend() const;</pre>
Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id328246-bb"></a>front() ;</pre>
+<pre class="literallayout">reference <a name="id328283-bb"></a>front() ;</pre>
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id328277-bb"></a>front() const;</pre>
+<pre class="literallayout">const_reference <a name="id328314-bb"></a>front() const;</pre>
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id328308-bb"></a>back() ;</pre>
+<pre class="literallayout">reference <a name="id328345-bb"></a>back() ;</pre>
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id328340-bb"></a>back() const;</pre>
+<pre class="literallayout">const_reference <a name="id328376-bb"></a>back() const;</pre>
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">pointer <a name="id328365-bb"></a>data() ;</pre>
+<pre class="literallayout">pointer <a name="id328402-bb"></a>data() ;</pre>
Returns: A pointer such that [data(),data() + size()) is a valid range. For a non-empty vector, data() == &front().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_pointer <a name="id328390-bb"></a>data() const;</pre>
+<pre class="literallayout">const_pointer <a name="id328427-bb"></a>data() const;</pre>
Returns: A pointer such that [data(),data() + size()) is a valid range. For a non-empty vector, data() == &front().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id328415-bb"></a>size() const;</pre>
+<pre class="literallayout">size_type <a name="id328452-bb"></a>size() const;</pre>
Effects: Returns the number of the elements contained in the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id328442-bb"></a>max_size() const;</pre>
+<pre class="literallayout">size_type <a name="id328478-bb"></a>max_size() const;</pre>
Effects: Returns the largest possible size of the vector.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">size_type <a name="id328467-bb"></a>capacity() const;</pre>
+<pre class="literallayout">size_type <a name="id328504-bb"></a>capacity() const;</pre>
Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">bool <a name="id328492-bb"></a>empty() const;</pre>
+<pre class="literallayout">bool <a name="id328529-bb"></a>empty() const;</pre>
Effects: Returns true if the vector contains no elements.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id328517-bb"></a>operator[](size_type n) ;</pre>
+<pre class="literallayout">reference <a name="id328554-bb"></a>operator[](size_type n) ;</pre>
Requires: size() < n.
Effects: Returns a reference to the nth element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id328553-bb"></a>operator[](size_type n) const;</pre>
+<pre class="literallayout">const_reference <a name="id328590-bb"></a>operator[](size_type n) const;</pre>
Requires: size() < n.
Effects: Returns a const reference to the nth element from the beginning of the container.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">reference <a name="id328589-bb"></a>at(size_type n) ;</pre>
+<pre class="literallayout">reference <a name="id328626-bb"></a>at(size_type n) ;</pre>
Requires: size() < n.
Effects: Returns a reference to the nth element from the beginning of the container.
Throws: std::range_error if n >= size()
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">const_reference <a name="id328625-bb"></a>at(size_type n) const;</pre>
+<pre class="literallayout">const_reference <a name="id328662-bb"></a>at(size_type n) const;</pre>
Requires: size() < n.
Effects: Returns a const reference to the nth element from the beginning of the container.
Throws: std::range_error if n >= size()
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">allocator_type <a name="id328661-bb"></a>get_allocator() const;</pre>
+<pre class="literallayout">allocator_type <a name="id328698-bb"></a>get_allocator() const;</pre>
Effects: Returns a copy of the internal allocator.
Throws: If allocator's copy constructor throws.
Complexity: Constant. 
</li>
-<li><pre class="literallayout">const stored_allocator_type & <a name="id328686-bb"></a>get_stored_allocator() const;</pre></li>
-<li><pre class="literallayout">stored_allocator_type & <a name="id328692-bb"></a>get_stored_allocator() ;</pre></li>
+<li><pre class="literallayout">const stored_allocator_type & <a name="id328723-bb"></a>get_stored_allocator() const;</pre></li>
+<li><pre class="literallayout">stored_allocator_type & <a name="id328729-bb"></a>get_stored_allocator() ;</pre></li>
<li>
-<pre class="literallayout">void <a name="id328698-bb"></a>reserve(size_type new_cap) ;</pre>
+<pre class="literallayout">void <a name="id328735-bb"></a>reserve(size_type new_cap) ;</pre>
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. 
</li>
<li>
-<pre class="literallayout">void <a name="id328722-bb"></a>assign(size_type n, const value_type & val) ;</pre>
+<pre class="literallayout">void <a name="id328759-bb"></a>assign(size_type n, const value_type & val) ;</pre>
Effects: Assigns the n copies of val to *this.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">template<typename InIt> void <a name="id328758-bb"></a>assign(InIt first, InIt last) ;</pre>
+<pre class="literallayout">template<typename InIt> void <a name="id328795-bb"></a>assign(InIt first, InIt last) ;</pre>
Effects: Assigns the the range [first, last) to *this.
Throws: If memory allocation throws or T's constructor from dereferencing InpIt throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">void <a name="id328799-bb"></a>push_back(const T & x) ;</pre>
+<pre class="literallayout">void <a name="id328836-bb"></a>push_back(const T & x) ;</pre>
Effects: Inserts a copy of x at the end of the vector.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">void <a name="id328830-bb"></a>push_back(BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">void <a name="id328867-bb"></a>push_back(T && x) ;</pre>
Effects: Constructs a new element in the end of the vector and moves the resources of mx to this new element.
Throws: If memory allocation throws.
Complexity: Amortized constant time. 
</li>
<li>
-<pre class="literallayout">template<class... Args> void <a name="id328860-bb"></a>emplace_back(Args &&... args) ;</pre>
+<pre class="literallayout">template<class... Args> void <a name="id328897-bb"></a>emplace_back(Args &&... args) ;</pre>
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the vector.
Throws: If memory allocation throws or the in-place constructor throws.
Complexity: Amortized constant time. 
</li>
<li>
<pre class="literallayout">template<class... Args>
- iterator <a name="id328899-bb"></a>emplace(const_iterator position, Args &&... args) ;</pre>
+ iterator <a name="id328936-bb"></a>emplace(const_iterator position, Args &&... args) ;</pre>
Requires: position must be a valid iterator of *this.
Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before position
Throws: If memory allocation throws or the in-place constructor throws.
Complexity: If position is end(), amortized constant time Linear time otherwise. 
</li>
<li>
-<pre class="literallayout">void <a name="id328948-bb"></a>swap(vector & x) ;</pre>
+<pre class="literallayout">void <a name="id328985-bb"></a>swap(vector & x) ;</pre>
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id328980-bb"></a>insert(const_iterator position, const T & x) ;</pre>
+<pre class="literallayout">iterator <a name="id329017-bb"></a>insert(const_iterator position, const T & x) ;</pre>
Requires: position must be a valid iterator of *this.
Effects: Insert a copy of x before position.
Throws: If memory allocation throws or x's copy constructor throws.
Complexity: If position is end(), amortized constant time Linear time otherwise. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id329022-bb"></a>insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x) ;</pre>
+<pre class="literallayout">iterator <a name="id329059-bb"></a>insert(const_iterator position, T && x) ;</pre>
Requires: position must be a valid iterator of *this.
Effects: Insert a new element before position with mx's resources.
Throws: If memory allocation throws.
@@ -430,57 +430,57 @@
</li>
<li>
<pre class="literallayout">template<typename InIt>
- void <a name="id329064-bb"></a>insert(const_iterator pos, InIt first, InIt last) ;</pre>
+ void <a name="id329101-bb"></a>insert(const_iterator pos, InIt first, InIt last) ;</pre>
Requires: pos must be a valid iterator of *this.
Effects: Insert a copy of the [first, last) range before pos.
Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws or T's copy constructor throws.
Complexity: Linear to std::distance [first, last). 
</li>
<li>
-<pre class="literallayout">void <a name="id329116-bb"></a>insert(const_iterator p, size_type n, const T & x) ;</pre>
+<pre class="literallayout">void <a name="id329153-bb"></a>insert(const_iterator p, size_type n, const T & x) ;</pre>
Requires: pos must be a valid iterator of *this.
Effects: Insert n copies of x before pos.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n. 
</li>
<li>
-<pre class="literallayout">void <a name="id329163-bb"></a>pop_back() ;</pre>
+<pre class="literallayout">void <a name="id329200-bb"></a>pop_back() ;</pre>
Effects: Removes the last element from the vector.
Throws: Nothing.
Complexity: Constant time. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id329188-bb"></a>erase(const_iterator position) ;</pre>
+<pre class="literallayout">iterator <a name="id329225-bb"></a>erase(const_iterator position) ;</pre>
Effects: Erases the element at position pos.
Throws: Nothing.
Complexity: Linear to the elements between pos and the last element. Constant if pos is the first or the last element. 
</li>
<li>
-<pre class="literallayout">iterator <a name="id329218-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
+<pre class="literallayout">iterator <a name="id329255-bb"></a>erase(const_iterator first, const_iterator last) ;</pre>
Effects: Erases the elements pointed by [first, last).
Throws: Nothing.
Complexity: Linear to the distance between first and last. 
</li>
<li>
-<pre class="literallayout">void <a name="id329253-bb"></a>resize(size_type new_size, const T & x) ;</pre>
+<pre class="literallayout">void <a name="id329290-bb"></a>resize(size_type new_size, const T & x) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id329290-bb"></a>resize(size_type new_size) ;</pre>
+<pre class="literallayout">void <a name="id329327-bb"></a>resize(size_type new_size) ;</pre>
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default constructed.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size. 
</li>
<li>
-<pre class="literallayout">void <a name="id329322-bb"></a>clear() ;</pre>
+<pre class="literallayout">void <a name="id329359-bb"></a>clear() ;</pre>
Effects: Erases all the elements of the vector.
Throws: Nothing.
Complexity: Linear to the number of elements in the vector. 
</li>
<li>
-<pre class="literallayout">void <a name="id329348-bb"></a>shrink_to_fit() ;</pre>
+<pre class="literallayout">void <a name="id329384-bb"></a>shrink_to_fit() ;</pre>
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().

Modified: sandbox/move/libs/container/doc/html/boost/container/wstring.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost/container/wstring.html (original)
+++ sandbox/move/libs/container/doc/html/boost/container/wstring.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -34,7 +34,7 @@

typedef basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > wstring;</pre></div>
<div class="refsect1" lang="en">
-<a name="id554896"></a><h2>Description</h2>
+<a name="id538713"></a><h2>Description</h2>
Typedef for a basic_string of narrow characters 
</div>
</div>

Modified: sandbox/move/libs/container/doc/html/boost_container_reference.html
==============================================================================
--- sandbox/move/libs/container/doc/html/boost_container_reference.html (original)
+++ sandbox/move/libs/container/doc/html/boost_container_reference.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -44,7 +44,7 @@
<pre class="synopsis">namespace boost {
 namespace container {
 struct ordered_range_impl_t;
- struct ordered_unique_range_impl_t;
+ struct ordered_unique_range_impl_t;

 static const ordered_range_t ordered_range;
 static const ordered_unique_range_t ordered_unique_range;
@@ -58,23 +58,23 @@
 namespace container {
 template<typename T, typename Alloc> class deque;
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator==_id294525"></a>operator==(const deque< T, Alloc > & x,
+ bool <a name="boost.container.operator==_id294263"></a>operator==(const deque< T, Alloc > & x,
 const deque< T, Alloc > & y);
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator_id294556"></a>operator<(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
+ bool <a name="boost.container.operator_id294294"></a>operator<(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator!=_id294588"></a>operator!=(const deque< T, Alloc > & x,
+ bool <a name="boost.container.operator!=_id294325"></a>operator!=(const deque< T, Alloc > & x,
 const deque< T, Alloc > & y);
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator_id294619"></a>operator>(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
+ bool <a name="boost.container.operator_id294356"></a>operator>(const deque< T, Alloc > & x, const deque< T, Alloc > & y);
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator_=_id294650"></a>operator<=(const deque< T, Alloc > & x,
+ bool <a name="boost.container.operator_=_id294388"></a>operator<=(const deque< T, Alloc > & x,
 const deque< T, Alloc > & y);
 template<typename T, typename Alloc>
- bool <a name="boost.container.operator_=_id294681"></a>operator>=(const deque< T, Alloc > & x,
+ bool <a name="boost.container.operator_=_id294419"></a>operator>=(const deque< T, Alloc > & x,
 const deque< T, Alloc > & y);
 template<typename T, typename A>
- void <a name="boost.container.swap_id294712"></a>swap(deque< T, A > & x, deque< T, A > & y);
+ void <a name="boost.container.swap_id294450"></a>swap(deque< T, A > & x, deque< T, A > & y);
 }
}</pre>
</div>
@@ -88,46 +88,46 @@
 template<typename Key, typename T, typename Pred, typename Alloc>
 class flat_multimap;
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id298098"></a>operator==(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id298011"></a>operator==(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id298136"></a>operator<(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id298050"></a>operator<(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id298175"></a>operator!=(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id298088"></a>operator!=(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id298213"></a>operator>(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id298126"></a>operator>(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id298252"></a>operator<=(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id298165"></a>operator<=(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id298290"></a>operator>=(const flat_map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id298203"></a>operator>=(const flat_map< Key, T, Pred, Alloc > & x,
 const flat_map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id298328"></a>swap(flat_map< Key, T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id298242"></a>swap(flat_map< Key, T, Pred, Alloc > & x,
 <a href="boost/container/flat_map.html" title="Class template flat_map">flat_map</a>< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id298364"></a>operator==(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id298278"></a>operator==(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id298403"></a>operator<(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id298316"></a>operator<(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id298441"></a>operator!=(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id298354"></a>operator!=(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id298480"></a>operator>(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id298393"></a>operator>(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id298518"></a>operator<=(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id298431"></a>operator<=(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id298556"></a>operator>=(const flat_multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id298470"></a>operator>=(const flat_multimap< Key, T, Pred, Alloc > & x,
 const flat_multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id298595"></a>swap(flat_multimap< Key, T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id298508"></a>swap(flat_multimap< Key, T, Pred, Alloc > & x,
 <a href="boost/container/flat_multimap.html" title="Class template flat_multimap">flat_multimap</a>< Key, T, Pred, Alloc > & y);
 }
}</pre>
@@ -140,46 +140,46 @@
 template<typename T, typename Pred, typename Alloc> class flat_set;
 template<typename T, typename Pred, typename Alloc> class flat_multiset;
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id303686"></a>operator==(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id303659"></a>operator==(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id303721"></a>operator<(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id303694"></a>operator<(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id303756"></a>operator!=(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id303729"></a>operator!=(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id303790"></a>operator>(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id303764"></a>operator>(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id303825"></a>operator<=(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id303798"></a>operator<=(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id303860"></a>operator>=(const flat_set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id303833"></a>operator>=(const flat_set< T, Pred, Alloc > & x,
 const flat_set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id303895"></a>swap(flat_set< T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id303868"></a>swap(flat_set< T, Pred, Alloc > & x,
 <a href="boost/container/flat_set.html" title="Class template flat_set">flat_set</a>< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id303927"></a>operator==(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id303900"></a>operator==(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id303962"></a>operator<(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id303935"></a>operator<(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id303997"></a>operator!=(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id303970"></a>operator!=(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id304032"></a>operator>(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id304005"></a>operator>(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id304066"></a>operator<=(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id304040"></a>operator<=(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id304101"></a>operator>=(const flat_multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id304074"></a>operator>=(const flat_multiset< T, Pred, Alloc > & x,
 const flat_multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id304136"></a>swap(flat_multiset< T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id304109"></a>swap(flat_multiset< T, Pred, Alloc > & x,
 <a href="boost/container/flat_multiset.html" title="Class template flat_multiset">flat_multiset</a>< T, Pred, Alloc > & y);
 }
}</pre>
@@ -191,19 +191,19 @@
 namespace container {
 template<typename T, typename A> class list;
 template<typename T, typename A>
- bool <a name="boost.container.operator==_id308066"></a>operator==(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator==_id307987"></a>operator==(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_id308097"></a>operator<(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator_id308018"></a>operator<(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator!=_id308129"></a>operator!=(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator!=_id308049"></a>operator!=(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_id308160"></a>operator>(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator_id308080"></a>operator>(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_=_id308191"></a>operator<=(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator_=_id308112"></a>operator<=(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_=_id308222"></a>operator>=(const list< T, A > & x, const list< T, A > & y);
+ bool <a name="boost.container.operator_=_id308143"></a>operator>=(const list< T, A > & x, const list< T, A > & y);
 template<typename T, typename A>
- void <a name="boost.container.swap_id308253"></a>swap(list< T, A > & x, list< T, A > & y);
+ void <a name="boost.container.swap_id308174"></a>swap(list< T, A > & x, list< T, A > & y);
 }
}</pre>
</div>
@@ -216,46 +216,46 @@
 template<typename Key, typename T, typename Pred, typename Alloc>
 class multimap;
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id311512"></a>operator==(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id311436"></a>operator==(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id311550"></a>operator<(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id311474"></a>operator<(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id311588"></a>operator!=(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id311513"></a>operator!=(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id311627"></a>operator>(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id311551"></a>operator>(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id311665"></a>operator<=(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id311589"></a>operator<=(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id311704"></a>operator>=(const map< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id311628"></a>operator>=(const map< Key, T, Pred, Alloc > & x,
 const map< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id311742"></a>swap(map< Key, T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id311666"></a>swap(map< Key, T, Pred, Alloc > & x,
 <a href="boost/container/map.html" title="Class template map">map</a>< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id311778"></a>operator==(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id311702"></a>operator==(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id311816"></a>operator<(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id311741"></a>operator<(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id311855"></a>operator!=(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id311779"></a>operator!=(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id311893"></a>operator>(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id311817"></a>operator>(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id311932"></a>operator<=(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id311856"></a>operator<=(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id311970"></a>operator>=(const multimap< Key, T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id311894"></a>operator>=(const multimap< Key, T, Pred, Alloc > & x,
 const multimap< Key, T, Pred, Alloc > & y);
 template<typename Key, typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id312560"></a>swap(multimap< Key, T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id312484"></a>swap(multimap< Key, T, Pred, Alloc > & x,
 <a href="boost/container/multimap.html" title="Class template multimap">multimap</a>< Key, T, Pred, Alloc > & y);
 }
}</pre>
@@ -268,45 +268,45 @@
 template<typename T, typename Pred, typename Alloc> class set;
 template<typename T, typename Pred, typename Alloc> class multiset;
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id316958"></a>operator==(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id316877"></a>operator==(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id316992"></a>operator<(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id316912"></a>operator<(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id317027"></a>operator!=(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id316947"></a>operator!=(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id317062"></a>operator>(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id316981"></a>operator>(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id317097"></a>operator<=(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id317016"></a>operator<=(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id317132"></a>operator>=(const set< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id317051"></a>operator>=(const set< T, Pred, Alloc > & x,
 const set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id317166"></a>swap(set< T, Pred, Alloc > & x, set< T, Pred, Alloc > & y);
+ void <a name="boost.container.swap_id317086"></a>swap(set< T, Pred, Alloc > & x, set< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator==_id317199"></a>operator==(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator==_id317118"></a>operator==(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id317234"></a>operator<(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id317153"></a>operator<(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator!=_id317268"></a>operator!=(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator!=_id317188"></a>operator!=(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_id317303"></a>operator>(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_id317223"></a>operator>(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id317338"></a>operator<=(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id317257"></a>operator<=(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- bool <a name="boost.container.operator_=_id317373"></a>operator>=(const multiset< T, Pred, Alloc > & x,
+ bool <a name="boost.container.operator_=_id317292"></a>operator>=(const multiset< T, Pred, Alloc > & x,
 const multiset< T, Pred, Alloc > & y);
 template<typename T, typename Pred, typename Alloc>
- void <a name="boost.container.swap_id317408"></a>swap(multiset< T, Pred, Alloc > & x,
+ void <a name="boost.container.swap_id317327"></a>swap(multiset< T, Pred, Alloc > & x,
 <a href="boost/container/multiset.html" title="Class template multiset">multiset</a>< T, Pred, Alloc > & y);
 }
}</pre>
@@ -318,19 +318,19 @@
 namespace container {
 template<typename T, typename A> class slist;
 template<typename T, typename A>
- bool <a name="boost.container.operator==_id320033"></a>operator==(const slist< T, A > & x, const slist< T, A > & y);
+ bool <a name="boost.container.operator==_id319950"></a>operator==(const slist< T, A > & x, const slist< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_id320064"></a>operator<(const slist< T, A > & sL1, const slist< T, A > & sL2);
+ bool <a name="boost.container.operator_id319982"></a>operator<(const slist< T, A > & sL1, const slist< T, A > & sL2);
 template<typename T, typename A>
- bool <a name="boost.container.operator!=_id320096"></a>operator!=(const slist< T, A > & sL1, const slist< T, A > & sL2);
+ bool <a name="boost.container.operator!=_id320013"></a>operator!=(const slist< T, A > & sL1, const slist< T, A > & sL2);
 template<typename T, typename A>
- bool <a name="boost.container.operator_id320127"></a>operator>(const slist< T, A > & sL1, const slist< T, A > & sL2);
+ bool <a name="boost.container.operator_id320044"></a>operator>(const slist< T, A > & sL1, const slist< T, A > & sL2);
 template<typename T, typename A>
- bool <a name="boost.container.operator_=_id320158"></a>operator<=(const slist< T, A > & sL1, const slist< T, A > & sL2);
+ bool <a name="boost.container.operator_=_id320075"></a>operator<=(const slist< T, A > & sL1, const slist< T, A > & sL2);
 template<typename T, typename A>
- bool <a name="boost.container.operator_=_id320189"></a>operator>=(const slist< T, A > & sL1, const slist< T, A > & sL2);
+ bool <a name="boost.container.operator_=_id320106"></a>operator>=(const slist< T, A > & sL1, const slist< T, A > & sL2);
 template<typename T, typename A>
- void <a name="boost.container.swap_id320220"></a>swap(slist< T, A > & x, slist< T, A > & y);
+ void <a name="boost.container.swap_id320138"></a>swap(slist< T, A > & x, slist< T, A > & y);
 }
}</pre>
</div>
@@ -341,25 +341,25 @@
 namespace container {
 template<typename T, typename Allocator> class stable_vector;
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator==_id321368"></a>operator==(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator==_id321351"></a>operator==(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator_id321399"></a>operator<(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator_id321382"></a>operator<(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator!=_id321430"></a>operator!=(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator!=_id321413"></a>operator!=(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator_id321462"></a>operator>(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator_id321444"></a>operator>(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator_=_id321493"></a>operator>=(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator_=_id321476"></a>operator>=(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- bool <a name="boost.container.operator_=_id321524"></a>operator<=(const stable_vector< T, Allocator > & x,
+ bool <a name="boost.container.operator_=_id321507"></a>operator<=(const stable_vector< T, Allocator > & x,
 const stable_vector< T, Allocator > & y);
 template<typename T, typename Allocator>
- void <a name="boost.container.swap_id321555"></a>swap(stable_vector< T, Allocator > & x,
+ void <a name="boost.container.swap_id321538"></a>swap(stable_vector< T, Allocator > & x,
 <a href="boost/container/stable_vector.html" title="Class template stable_vector">stable_vector</a>< T, Allocator > & y);
 }
}</pre>
@@ -374,110 +374,116 @@
 typedef basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > wstring;
 template<typename CharT, typename Traits, typename A>
 basic_string< CharT, Traits, A >
- <a name="boost.container.operator+_id326411"></a>operator+(const basic_string< CharT, Traits, A > & x,
+ <a name="boost.container.operator+_id326390"></a>operator+(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326448"></a>operator+(BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx,
- const basic_string< CharT, Traits, A > & y);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326428"></a>operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
+ const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326482"></a>operator+(const basic_string< CharT, Traits, A > & x,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326471"></a>operator+(const basic_string< CharT, Traits, A > & x,
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
 template<typename CharT, typename Traits, typename A>
 basic_string< CharT, Traits, A >
- <a name="boost.container.operator+_id326516"></a>operator+(const CharT * s, const basic_string< CharT, Traits, A > & y);
+ <a name="boost.container.operator+_id326514"></a>operator+(const CharT * s, const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326549"></a>operator+(const CharT * s,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326548"></a>operator+(const CharT * s,
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
 template<typename CharT, typename Traits, typename A>
 basic_string< CharT, Traits, A >
- <a name="boost.container.operator+_id326579"></a>operator+(CharT c, const basic_string< CharT, Traits, A > & y);
+ <a name="boost.container.operator+_id326587"></a>operator+(CharT c, const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326613"></a>operator+(CharT c,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326621"></a>operator+(CharT c,
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && my);
 template<typename CharT, typename Traits, typename A>
 basic_string< CharT, Traits, A >
- <a name="boost.container.operator+_id326643"></a>operator+(const basic_string< CharT, Traits, A > & x, const CharT * s);
+ <a name="boost.container.operator+_id326660"></a>operator+(const basic_string< CharT, Traits, A > & x, const CharT * s);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326676"></a>operator+(BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx,
- const CharT * s);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326694"></a>operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
+ const CharT * s);
 template<typename CharT, typename Traits, typename A>
 basic_string< CharT, Traits, A >
- <a name="boost.container.operator+_id326706"></a>operator+(const basic_string< CharT, Traits, A > & x, const CharT c);
+ <a name="boost.container.operator+_id326734"></a>operator+(const basic_string< CharT, Traits, A > & x, const CharT c);
 template<typename CharT, typename Traits, typename A>
- <a name="boost.container.operator+_id326740"></a>operator+(BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx,
- const CharT c);
+ basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > &&
+ <a name="boost.container.operator+_id326767"></a>operator+(basic_string< CharT, Traits, A > basic_string< CharT, Traits, A > && mx,
+ const CharT c);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator==_id326770"></a>operator==(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator==_id326807"></a>operator==(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator==_id326805"></a>operator==(const CharT * s,
+ bool <a name="boost.container.operator==_id326842"></a>operator==(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator==_id326836"></a>operator==(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator==_id326873"></a>operator==(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator!=_id326867"></a>operator!=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator!=_id326904"></a>operator!=(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator!=_id326902"></a>operator!=(const CharT * s,
+ bool <a name="boost.container.operator!=_id326939"></a>operator!=(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator!=_id326933"></a>operator!=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator!=_id326970"></a>operator!=(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id326964"></a>operator<(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_id327001"></a>operator<(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id326999"></a>operator<(const CharT * s,
+ bool <a name="boost.container.operator_id327036"></a>operator<(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id327030"></a>operator<(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_id327067"></a>operator<(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id327062"></a>operator>(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_id327098"></a>operator>(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id327096"></a>operator>(const CharT * s,
+ bool <a name="boost.container.operator_id327133"></a>operator>(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_id327128"></a>operator>(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_id327164"></a>operator>(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327159"></a>operator<=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_=_id327196"></a>operator<=(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327194"></a>operator<=(const CharT * s,
+ bool <a name="boost.container.operator_=_id327230"></a>operator<=(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327225"></a>operator<=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_=_id327548"></a>operator<=(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327543"></a>operator>=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_=_id327580"></a>operator>=(const basic_string< CharT, Traits, A > & x,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327578"></a>operator>=(const CharT * s,
+ bool <a name="boost.container.operator_=_id327614"></a>operator>=(const CharT * s,
 const basic_string< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
- bool <a name="boost.container.operator_=_id327609"></a>operator>=(const basic_string< CharT, Traits, A > & x,
+ bool <a name="boost.container.operator_=_id327646"></a>operator>=(const basic_string< CharT, Traits, A > & x,
 const CharT * s);
 template<typename CharT, typename Traits, typename A>
- void <a name="boost.container.swap_id327640"></a>swap(basic_string< CharT, Traits, A > & x,
+ void <a name="boost.container.swap_id327677"></a>swap(basic_string< CharT, Traits, A > & x,
 <a href="boost/container/basic_string.html" title="Class template basic_string">basic_string</a>< CharT, Traits, A > & y);
 template<typename CharT, typename Traits, typename A>
 std::basic_ostream< CharT, Traits > &
- <a name="boost.container.operator_id327672"></a>operator<<(std::basic_ostream< CharT, Traits > & os,
+ <a name="boost.container.operator_id327709"></a>operator<<(std::basic_ostream< CharT, Traits > & os,
 const basic_string< CharT, Traits, A > & s);
 template<typename CharT, typename Traits, typename A>
 std::basic_istream< CharT, Traits > &
- <a name="boost.container.operator_id327704"></a>operator>>(std::basic_istream< CharT, Traits > & is,
+ <a name="boost.container.operator_id327740"></a>operator>>(std::basic_istream< CharT, Traits > & is,
 <a href="boost/container/basic_string.html" title="Class template basic_string">basic_string</a>< CharT, Traits, A > & s);
 template<typename CharT, typename Traits, typename A>
 std::basic_istream< CharT, Traits > &
- <a name="boost.container.getline_id327734"></a>getline(std::istream & is, basic_string< CharT, Traits, A > & s,
+ <a name="boost.container.getline_id327770"></a>getline(std::istream & is, basic_string< CharT, Traits, A > & s,
 CharT delim);
 template<typename CharT, typename Traits, typename A>
 std::basic_istream< CharT, Traits > &
- <a name="boost.container.getline_id327768"></a>getline(std::basic_istream< CharT, Traits > & is,
+ <a name="boost.container.getline_id327805"></a>getline(std::basic_istream< CharT, Traits > & is,
 <a href="boost/container/basic_string.html" title="Class template basic_string">basic_string</a>< CharT, Traits, A > & s);
 template<typename Ch, typename A>
 std::size_t <a name="boost.container.hash_value"></a>hash_value(basic_string< Ch, std::char_traits< Ch >, A > const & v);
@@ -491,13 +497,13 @@
 namespace container {
 template<typename T, typename A> class vector;
 template<typename T, typename A>
- bool <a name="boost.container.operator==_id329658"></a>operator==(const vector< T, A > & x, const vector< T, A > & y);
+ bool <a name="boost.container.operator==_id329693"></a>operator==(const vector< T, A > & x, const vector< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator!=_id329690"></a>operator!=(const vector< T, A > & x, const vector< T, A > & y);
+ bool <a name="boost.container.operator!=_id329805"></a>operator!=(const vector< T, A > & x, const vector< T, A > & y);
 template<typename T, typename A>
- bool <a name="boost.container.operator_id329870"></a>operator<(const vector< T, A > & x, const vector< T, A > & y);
+ bool <a name="boost.container.operator_id329836"></a>operator<(const vector< T, A > & x, const vector< T, A > & y);
 template<typename T, typename A>
- void <a name="boost.container.swap_id329901"></a>swap(vector< T, A > & x, vector< T, A > & y);
+ void <a name="boost.container.swap_id329867"></a>swap(vector< T, A > & x, vector< T, A > & y);
 }
}</pre>
</div>

Modified: sandbox/move/libs/container/doc/html/index.html
==============================================================================
--- sandbox/move/libs/container/doc/html/index.html (original)
+++ sandbox/move/libs/container/doc/html/index.html 2010-05-27 13:05:27 EDT (Thu, 27 May 2010)
@@ -27,7 +27,7 @@
</h3></div></div>
<div>Copyright © 2009 -2010 Ion Gaztanaga</div>
<div><div class="legalnotice">
-<a name="id476068"></a>
+<a name="id459684"></a>
 Distributed under the Boost Software License, Version 1.0. (See accompanying
 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -86,7 +86,7 @@
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: May 27, 2010 at 15:57:36 GMT</td>
+<td align="left">Last revised: May 27, 2010 at 17:00:45 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Next message: jewillco_at_[hidden]: "[Boost-commit] svn:boost r62271 - trunk/boost/graph/distributed"
Previous message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r62269 - sandbox/move/libs/container/doc/html/images"

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