Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r73291 - in sandbox/move/boost: container container/detail intrusive intrusive/detail move
From: igaztanaga_at_[hidden]
Date: 2011-07-21 19:05:24

Author: igaztanaga
Date: 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
New Revision: 73291
URL: http://svn.boost.org/trac/boost/changeset/73291

Log:
Updated Container to latest version
Added:
   sandbox/move/boost/container/detail/stored_ref.hpp (contents, props changed)
   sandbox/move/boost/intrusive/parent_from_member.hpp (contents, props changed)
   sandbox/move/boost/move/move_helpers.hpp (contents, props changed)
Text files modified:
   sandbox/move/boost/container/container_fwd.hpp | 11
   sandbox/move/boost/container/deque.hpp | 637 ++++++++++++++++++++++++++++++--------
   sandbox/move/boost/container/detail/adaptive_node_pool_impl.hpp | 222 +++++++------
   sandbox/move/boost/container/detail/advanced_insert_int.hpp | 65 ++-
   sandbox/move/boost/container/detail/algorithms.hpp | 4
   sandbox/move/boost/container/detail/config_begin.hpp | 15
   sandbox/move/boost/container/detail/destroyers.hpp | 2
   sandbox/move/boost/container/detail/flat_tree.hpp | 76 ++--
   sandbox/move/boost/container/detail/iterators.hpp | 84 ++++
   sandbox/move/boost/container/detail/math_functions.hpp | 3
   sandbox/move/boost/container/detail/mpl.hpp | 3
   sandbox/move/boost/container/detail/multiallocation_chain.hpp | 43 +-
   sandbox/move/boost/container/detail/node_alloc_holder.hpp | 36 +-
   sandbox/move/boost/container/detail/node_pool_impl.hpp | 57 +-
   sandbox/move/boost/container/detail/pair.hpp | 204 +++++++++--
   sandbox/move/boost/container/detail/preprocessor.hpp | 46 ++
   sandbox/move/boost/container/detail/transform_iterator.hpp | 4
   sandbox/move/boost/container/detail/tree.hpp | 99 +++--
   sandbox/move/boost/container/detail/type_traits.hpp | 41 ++
   sandbox/move/boost/container/detail/utilities.hpp | 28
   sandbox/move/boost/container/detail/version_type.hpp | 3
   sandbox/move/boost/container/detail/workaround.hpp | 4
   sandbox/move/boost/container/flat_map.hpp | 70 ++--
   sandbox/move/boost/container/flat_set.hpp | 58 +-
   sandbox/move/boost/container/list.hpp | 126 +++---
   sandbox/move/boost/container/map.hpp | 134 ++++---
   sandbox/move/boost/container/set.hpp | 60 +-
   sandbox/move/boost/container/slist.hpp | 46 +-
   sandbox/move/boost/container/stable_vector.hpp | 595 +++++++++++++++++++++++++++++------
   sandbox/move/boost/container/string.hpp | 118 +++---
   sandbox/move/boost/container/vector.hpp | 228 ++++++++-----
   sandbox/move/boost/intrusive/avl_set.hpp | 52 ++
   sandbox/move/boost/intrusive/avltree.hpp | 59 ++
   sandbox/move/boost/intrusive/circular_slist_algorithms.hpp | 2
   sandbox/move/boost/intrusive/derivation_value_traits.hpp | 12
   sandbox/move/boost/intrusive/detail/hashtable_node.hpp | 28 +
   sandbox/move/boost/intrusive/detail/mpl.hpp | 57 +--
   sandbox/move/boost/intrusive/detail/parent_from_member.hpp | 12
   sandbox/move/boost/intrusive/detail/transform_iterator.hpp | 2
   sandbox/move/boost/intrusive/detail/tree_node.hpp | 2
   sandbox/move/boost/intrusive/detail/utilities.hpp | 101 ++++-
   sandbox/move/boost/intrusive/hashtable.hpp | 137 ++++++--
   sandbox/move/boost/intrusive/intrusive_fwd.hpp | 83 ++--
   sandbox/move/boost/intrusive/list.hpp | 39 +
   sandbox/move/boost/intrusive/options.hpp | 20 +
   sandbox/move/boost/intrusive/rbtree.hpp | 48 ++
   sandbox/move/boost/intrusive/rbtree_algorithms.hpp | 1
   sandbox/move/boost/intrusive/set.hpp | 52 ++
   sandbox/move/boost/intrusive/sg_set.hpp | 50 ++
   sandbox/move/boost/intrusive/sgtree.hpp | 48 ++
   sandbox/move/boost/intrusive/slist.hpp | 43 +
   sandbox/move/boost/intrusive/splay_set.hpp | 52 ++
   sandbox/move/boost/intrusive/splaytree.hpp | 47 ++
   sandbox/move/boost/intrusive/treap.hpp | 60 ++
   sandbox/move/boost/intrusive/treap_set.hpp | 52 ++
   sandbox/move/boost/intrusive/unordered_set.hpp | 61 ++
   sandbox/move/boost/intrusive/unordered_set_hook.hpp | 6
   sandbox/move/boost/move/move.hpp | 658 ++++++++++++++++++++-------------------
   58 files changed, 3286 insertions(+), 1620 deletions(-)

Modified: sandbox/move/boost/container/container_fwd.hpp
==============================================================================
--- sandbox/move/boost/container/container_fwd.hpp (original)
+++ sandbox/move/boost/container/container_fwd.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -32,6 +32,8 @@

}}}

+#ifndef _LIBCPP_VERSION
+
namespace std {

template <class T>
@@ -48,6 +50,15 @@

} //namespace std {

+#else
+
+#include <utility>
+#include <memory>
+#include <functional>
+#include <iosfwd>
+
+#endif
+
/// @endcond

//////////////////////////////////////////////////////////////////////////////

Modified: sandbox/move/boost/container/deque.hpp
==============================================================================
--- sandbox/move/boost/container/deque.hpp (original)
+++ sandbox/move/boost/container/deque.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -25,7 +25,7 @@
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <cstddef>
#include <iterator>
-#include <cassert>
+#include <boost/assert.hpp>
#include <memory>
#include <algorithm>
#include <stdexcept>
@@ -35,7 +35,8 @@
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -82,7 +83,8 @@
 typedef typename Alloc::const_pointer val_alloc_cptr;
 typedef typename Alloc::reference val_alloc_ref;
 typedef typename Alloc::const_reference val_alloc_cref;
- typedef typename Alloc::value_type val_alloc_diff;
+ typedef typename Alloc::difference_type val_alloc_diff;
+ typedef typename Alloc::size_type val_alloc_size;
 typedef typename Alloc::template rebind
 <typename Alloc::pointer>::other ptr_alloc_t;
 typedef typename ptr_alloc_t::value_type ptr_alloc_val;
@@ -93,6 +95,7 @@
 typedef typename Alloc::template
 rebind<T>::other allocator_type;
 typedef allocator_type stored_allocator_type;
+ typedef val_alloc_size size_type;

 protected:

@@ -100,7 +103,7 @@
 typedef typename Alloc::template
 rebind<typename Alloc::pointer>::other map_allocator_type;

- static std::size_t s_buffer_size() { return deque_buf_size(sizeof(T)); }
+ static size_type s_buffer_size() { return deque_buf_size(sizeof(T)); }

 val_alloc_ptr priv_allocate_node()
 { return this->alloc().allocate(s_buffer_size()); }
@@ -108,10 +111,10 @@
 void priv_deallocate_node(val_alloc_ptr p)
 { this->alloc().deallocate(p, s_buffer_size()); }

- ptr_alloc_ptr priv_allocate_map(std::size_t n)
+ ptr_alloc_ptr priv_allocate_map(size_type n)
 { return this->ptr_alloc().allocate(n); }

- void priv_deallocate_map(ptr_alloc_ptr p, std::size_t n)
+ void priv_deallocate_map(ptr_alloc_ptr p, size_type n)
 { this->ptr_alloc().deallocate(p, n); }

 public:
@@ -145,14 +148,13 @@
 val_alloc_cptr, val_alloc_cref>
 {
 public:
- static std::size_t s_buffer_size() { return deque_base<T, Alloc>::s_buffer_size(); }
+ static size_type s_buffer_size() { return deque_base<T, Alloc>::s_buffer_size(); }

 typedef std::random_access_iterator_tag iterator_category;
 typedef val_alloc_val value_type;
 typedef val_alloc_cptr pointer;
 typedef val_alloc_cref reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef val_alloc_diff difference_type;

 typedef ptr_alloc_ptr index_pointer;
 typedef const_iterator self_t;
@@ -282,7 +284,7 @@
 this->m_last = this->m_first + difference_type(this->s_buffer_size());
 }

- friend const_iterator operator+(std::ptrdiff_t n, const const_iterator& x)
+ friend const_iterator operator+(difference_type n, const const_iterator& x)
 { return x + n; }
 };

@@ -294,8 +296,7 @@
 typedef val_alloc_val value_type;
 typedef val_alloc_ptr pointer;
 typedef val_alloc_ref reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef val_alloc_diff difference_type;
 typedef ptr_alloc_ptr index_pointer;
 typedef const_iterator self_t;

@@ -351,7 +352,7 @@
 { return static_cast<const const_iterator&>(*this) - right; }
 };

- deque_base(const allocator_type& a, std::size_t num_elements)
+ deque_base(const allocator_type& a, size_type num_elements)
 : members_(a)
 { this->priv_initialize_map(num_elements); }

@@ -372,12 +373,12 @@

 protected:

- void priv_initialize_map(std::size_t num_elements)
+ void priv_initialize_map(size_type num_elements)
 {
// if(num_elements){
- std::size_t num_nodes = num_elements / s_buffer_size() + 1;
+ size_type num_nodes = num_elements / s_buffer_size() + 1;

- this->members_.m_map_size = containers_detail::max_value((std::size_t) InitialMapSize, num_nodes + 2);
+ this->members_.m_map_size = containers_detail::max_value((size_type) InitialMapSize, num_nodes + 2);
 this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);

 ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
@@ -422,6 +423,18 @@
 this->priv_deallocate_node(*n);
 }

+ void priv_clear_map()
+ {
+ if (this->members_.m_map) {
+ this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1);
+ this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
+ this->members_.m_map = 0;
+ this->members_.m_map_size = 0;
+ this->members_.m_start = iterator();
+ this->members_.m_finish = this->members_.m_start;
+ }
+ }
+
 enum { InitialMapSize = 8 };

 protected:
@@ -436,7 +449,7 @@
 {}

 ptr_alloc_ptr m_map;
- std::size_t m_map_size;
+ typename allocator_type::size_type m_map_size;
 iterator m_start;
 iterator m_finish;
 } members_;
@@ -461,8 +474,6 @@
class deque : protected deque_base<T, Alloc>
{
 /// @cond
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 typedef deque_base<T, Alloc> Base;

 public: // Basic types
@@ -471,6 +482,9 @@
 typedef typename Alloc::const_pointer val_alloc_cptr;
 typedef typename Alloc::reference val_alloc_ref;
 typedef typename Alloc::const_reference val_alloc_cref;
+ typedef typename Alloc::size_type val_alloc_size;
+ typedef typename Alloc::difference_type val_alloc_diff;
+
 typedef typename Alloc::template
 rebind<val_alloc_ptr>::other ptr_alloc_t;
 typedef typename ptr_alloc_t::value_type ptr_alloc_val;
@@ -485,9 +499,8 @@
 typedef val_alloc_cptr const_pointer;
 typedef val_alloc_ref reference;
 typedef val_alloc_cref const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
-
+ typedef val_alloc_size size_type;
+ typedef val_alloc_diff difference_type;
 typedef typename Base::allocator_type allocator_type;

 public: // Iterators
@@ -499,93 +512,271 @@

 /// @cond
 private: // Internal typedefs
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(deque)
+ BOOST_COPYABLE_AND_MOVABLE(deque)
 typedef ptr_alloc_ptr index_pointer;
- static std::size_t s_buffer_size()
+ static size_type s_buffer_size()
 { return Base::s_buffer_size(); }
 typedef containers_detail::advanced_insert_aux_int<value_type, iterator> advanced_insert_aux_int_t;
 typedef repeat_iterator<T, difference_type> r_iterator;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<r_iterator> move_it;
+ typedef boost::move_iterator<r_iterator> move_it;

 /// @endcond

+ //! Effects: Returns a copy of the internal allocator.
+ //!
+ //! Throws: If allocator's copy constructor throws.
+ //!
+ //! Complexity: Constant.
 allocator_type get_allocator() const { return Base::alloc(); }

 public: // Basic accessors

+ //! Effects: Returns an iterator to the first element contained in the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 iterator begin()
 { return this->members_.m_start; }

+ //! Effects: Returns an iterator to the end of the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 iterator end()
 { return this->members_.m_finish; }

+ //! Effects: Returns a const_iterator to the first element contained in the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator begin() const
 { return this->members_.m_start; }

+ //! Effects: Returns a const_iterator to the end of the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator end() const
 { return this->members_.m_finish; }

+ //! Effects: Returns a reverse_iterator pointing to the beginning
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reverse_iterator rbegin()
 { return reverse_iterator(this->members_.m_finish); }

+ //! Effects: Returns a reverse_iterator pointing to the end
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reverse_iterator rend()
 { return reverse_iterator(this->members_.m_start); }

+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(this->members_.m_finish); }

+ //! Effects: Returns a const_reverse_iterator pointing to the end
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(this->members_.m_start); }

+ //! Effects: Returns a const_iterator to the first element contained in the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator cbegin() const
 { return this->members_.m_start; }

+ //! Effects: Returns a const_iterator to the end of the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator cend() const
 { return this->members_.m_finish; }

+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(this->members_.m_finish); }

+ //! Effects: Returns a const_reverse_iterator pointing to the end
+ //! of the reversed deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(this->members_.m_start); }

+ //! Requires: size() < n.
+ //!
+ //! Effects: Returns a reference to the nth element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reference operator[](size_type n)
 { return this->members_.m_start[difference_type(n)]; }

+ //! Requires: size() < n.
+ //!
+ //! Effects: Returns a const reference to the nth element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference operator[](size_type n) const
 { return this->members_.m_start[difference_type(n)]; }

- void priv_range_check(size_type n) const
- { if (n >= this->size()) BOOST_RETHROW std::out_of_range("deque"); }
-
+ //! 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.
 reference at(size_type n)
 { this->priv_range_check(n); return (*this)[n]; }

+ //! 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.
 const_reference at(size_type n) const
 { this->priv_range_check(n); return (*this)[n]; }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a reference to the first
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reference front() { return *this->members_.m_start; }

- reference back() { return *(end()-1); }
-
+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a const reference to the first element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference front() const
 { return *this->members_.m_start; }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a reference to the last
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ reference back() { return *(end()-1); }
+
+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a const reference to the last
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference back() const { return *(cend()-1); }

+ //! Effects: Returns the number of the elements contained in the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 size_type size() const
 { return this->members_.m_finish - this->members_.m_start; }

+ //! Effects: Returns the largest possible size of the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 size_type max_size() const
 { return this->alloc().max_size(); }

+ //! Effects: Returns true if the deque contains no elements.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 bool empty() const
 { return this->members_.m_finish == this->members_.m_start; }

+ //! Effects: Constructs a deque taking the allocator as parameter.
+ //!
+ //! Throws: If allocator_type's copy constructor throws.
+ //!
+ //! Complexity: Constant.
 explicit deque(const allocator_type& a = allocator_type())
 : Base(a)
 {}

+ //! Effects: Constructs a deque 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.
+ explicit deque(size_type n) : Base(allocator_type(), n)
+ { this->resize(n); }
+
+ //! Effects: Constructs a deque 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.
+ deque(size_type n, const value_type& value,
+ const allocator_type& a = allocator_type()) : Base(a, n)
+ { this->priv_fill_initialize(value); }
+
+ //! Effects: Copy constructs a deque.
+ //!
+ //! Postcondition: x == *this.
+ //!
+ //! Complexity: Linear to the elements x contains.
 deque(const deque& x)
 : Base(x.alloc())
 {
@@ -595,34 +786,52 @@
 }
 }

- deque(BOOST_MOVE_MACRO_RV_REF(deque) mx)
+ //! Effects: Move constructor. Moves mx's resources to *this.
+ //!
+ //! Throws: If allocator_type's copy constructor throws.
+ //!
+ //! Complexity: Constant.
+ deque(BOOST_RV_REF(deque) mx)
 : Base(mx.alloc())
 { this->swap(mx); }

- deque(size_type n, const value_type& value,
- const allocator_type& a = allocator_type()) : Base(a, n)
- { this->priv_fill_initialize(value); }
-
- explicit deque(size_type n) : Base(allocator_type(), n)
- { this->resize(n); }
-
- // Check whether it's an integral type. If so, it's not an iterator.
+ //! Effects: Constructs a deque that will use a copy of allocator a
+ //! and inserts a copy of the range [first, last) in the deque.
+ //!
+ //! 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).
 template <class InpIt>
 deque(InpIt first, InpIt last, const allocator_type& a = allocator_type())
 : Base(a)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_initialize_dispatch(first, last, Result());
 }

+ //! Effects: Destroys the deque. All stored values are destroyed
+ //! and used memory is deallocated.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the number of elements.
 ~deque()
 {
 priv_destroy_range(this->members_.m_start, this->members_.m_finish);
 }

- deque& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(deque) x)
+ //! 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.
+ deque& operator= (BOOST_COPY_ASSIGN_REF(deque) x)
 {
 const size_type len = size();
 if (&x != this) {
@@ -635,15 +844,30 @@
 }
 }
 return *this;
- }
+ }

- deque& operator= (BOOST_MOVE_MACRO_RV_REF(deque) x)
+ //! 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.
+ deque& operator= (BOOST_RV_REF(deque) x)
 {
 this->clear();
 this->swap(x);
 return *this;
 }

+ //! Effects: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type()
+ //! allocators are also swapped.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 void swap(deque &x)
 {
 std::swap(this->members_.m_start, x.members_.m_start);
@@ -652,62 +876,74 @@
 std::swap(this->members_.m_map_size, x.members_.m_map_size);
 }

+ //! Effects: Assigns the n copies of val to *this.
+ //!
+ //! Throws: If memory allocation throws or T's copy constructor throws.
+ //!
+ //! Complexity: Linear to n.
 void assign(size_type n, const T& val)
 { this->priv_fill_assign(n, val); }

+ //! 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.
 template <class InpIt>
 void assign(InpIt first, InpIt last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_assign_dispatch(first, last, Result());
 }

- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_back(T &x) { push_back(const_cast<const T &>(x)); }
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! Effects: Inserts a copy of x at the end of the deque.
+ //!
+ //! Throws: If memory allocation throws or
+ //! T's copy constructor throws.
+ //!
+ //! Complexity: Amortized constant time.
+ void push_back(const T &x);

- template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { return priv_push_back(u); }
+ //! Effects: Constructs a new element in the end of the deque
+ //! and moves the resources of mx to this new element.
+ //!
+ //! Throws: If memory allocation throws.
+ //!
+ //! Complexity: Amortized constant time.
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
 #endif

- void push_back(insert_const_ref_type t)
- { return priv_push_back(t); }
-
- void push_back(BOOST_MOVE_MACRO_RV_REF(value_type) t)
- {
- if(this->priv_push_back_simple_available()){
- new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
- this->priv_push_back_simple_commit();
- }
- else{
- this->priv_insert_aux(cend(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
- }
- }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_front(T &x) { push_front(const_cast<const T &>(x)); }
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! Effects: Inserts a copy of x at the front of the deque.
+ //!
+ //! Throws: If memory allocation throws or
+ //! T's copy constructor throws.
+ //!
+ //! Complexity: Amortized constant time.
+ void push_front(const T &x);

- template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { return priv_push_front(u); }
+ //! Effects: Constructs a new element in the front of the deque
+ //! and moves the resources of mx to this new element.
+ //!
+ //! Throws: If memory allocation throws.
+ //!
+ //! Complexity: Amortized constant time.
+ void push_front(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_front, T, void, priv_push_front)
 #endif

- void push_front(insert_const_ref_type t)
- { return priv_push_front(t); }
-
- void push_front(BOOST_MOVE_MACRO_RV_REF(value_type) t)
- {
- if(this->priv_push_front_simple_available()){
- new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
- this->priv_push_front_simple_commit();
- }
- else{
- this->priv_insert_aux(cbegin(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
- }
- }
-
+ //! Effects: Removes the last element from the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant time.
 void pop_back()
 {
 if (this->members_.m_finish.m_cur != this->members_.m_finish.m_first) {
@@ -718,6 +954,11 @@
 this->priv_pop_back_aux();
 }

+ //! Effects: Removes the first element from the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant time.
 void pop_front()
 {
 if (this->members_.m_start.m_cur != this->members_.m_start.m_last - 1) {
@@ -728,94 +969,124 @@
 this->priv_pop_front_aux();
 }

- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)

- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
+ //! 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.
+ iterator insert(const_iterator position, const T &x);

- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) mx)
- {
- if (position == cbegin()) {
- this->push_front(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
- return begin();
- }
- else if (position == cend()) {
- this->push_back(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
- return(end()-1);
- }
- else {
- //Just call more general insert(pos, size, value) and return iterator
- size_type n = position - begin();
- this->priv_insert_aux(position, move_it(r_iterator(mx, 1)), move_it(r_iterator()));
- return iterator(this->begin() + n);
- }
- }
+ //! 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.
+ //!
+ //! Complexity: If position is end(), amortized constant time
+ //! Linear time otherwise.
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif

+ //! 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.
 void insert(const_iterator pos, size_type n, const value_type& x)
 { this->priv_fill_insert(pos, n, x); }

- // Check whether it's an integral type. If so, it's not an iterator.
+ //! 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).
 template <class InpIt>
 void insert(const_iterator pos, InpIt first, InpIt last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_insert_dispatch(pos, first, last, Result());
 }

 #if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the end of the deque.
+ //!
+ //! Throws: If memory allocation throws or the in-place constructor throws.
+ //!
+ //! Complexity: Amortized constant time
 template <class... Args>
 void emplace_back(Args&&... args)
 {
 if(this->priv_push_back_simple_available()){
- new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new(this->priv_push_back_simple_pos())value_type(boost::forward<Args>(args)...);
 this->priv_push_back_simple_commit();
 }
 else{
 typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
 this->priv_insert_aux_impl(this->cend(), 1, proxy);
 }
 }

+ //! Effects: Inserts an object of type T constructed with
+ //! std::forward<Args>(args)... in the beginning of the deque.
+ //!
+ //! Throws: If memory allocation throws or the in-place constructor throws.
+ //!
+ //! Complexity: Amortized constant time
 template <class... Args>
 void emplace_front(Args&&... args)
 {
 if(this->priv_push_front_simple_available()){
- new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new(this->priv_push_front_simple_pos())value_type(boost::forward<Args>(args)...);
 this->priv_push_front_simple_commit();
 }
 else{
 typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
 this->priv_insert_aux_impl(this->cbegin(), 1, proxy);
 }
 }

+ //! 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.
 template <class... Args>
 iterator emplace(const_iterator p, Args&&... args)
 {
 if(p == this->cbegin()){
- this->emplace_front(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace_front(boost::forward<Args>(args)...);
 return this->begin();
 }
 else if(p == this->cend()){
- this->emplace_back(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace_back(boost::forward<Args>(args)...);
 return (this->end()-1);
 }
 else{
 size_type n = p - this->cbegin();
 typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
 this->priv_insert_aux_impl(p, 1, proxy);
 return iterator(this->begin() + n);
 }
@@ -926,6 +1197,12 @@

 #endif //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

+ //! 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.
 void resize(size_type new_size, const value_type& x)
 {
 const size_type len = size();
@@ -935,6 +1212,12 @@
 this->insert(this->members_.m_finish, new_size - len, x);
 }

+ //! 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.
 void resize(size_type new_size)
 {
 const size_type len = size();
@@ -947,22 +1230,38 @@
 }
 }

+ //! Effects: Erases the element at position pos.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the elements between pos and the
+ //! last element (if pos is near the end) or the first element
+ //! if(pos is near the beginning).
+ //! Constant if pos is the first or the last element.
 iterator erase(const_iterator pos)
 {
 const_iterator next = pos;
 ++next;
 difference_type index = pos - this->members_.m_start;
 if (size_type(index) < (this->size() >> 1)) {
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(begin(), iterator(pos), iterator(next));
+ boost::move_backward(begin(), iterator(pos), iterator(next));
 pop_front();
 }
 else {
- BOOST_CONTAINER_MOVE_NAMESPACE::move(iterator(next), end(), iterator(pos));
+ boost::move(iterator(next), end(), iterator(pos));
 pop_back();
 }
 return this->members_.m_start + index;
 }

+ //! Effects: Erases the elements pointed by [first, last).
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the distance between first and
+ //! last plus the elements between pos and the
+ //! last element (if pos is near the end) or the first element
+ //! if(pos is near the beginning).
 iterator erase(const_iterator first, const_iterator last)
 {
 if (first == this->members_.m_start && last == this->members_.m_finish) {
@@ -973,15 +1272,15 @@
 difference_type n = last - first;
 difference_type elems_before = first - this->members_.m_start;
 if (elems_before < static_cast<difference_type>(this->size() - n) - elems_before) {
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(begin(), iterator(first), iterator(last));
+ boost::move_backward(begin(), iterator(first), iterator(last));
 iterator new_start = this->members_.m_start + n;
 if(!Base::traits_t::trivial_dctr_after_move)
 this->priv_destroy_range(this->members_.m_start, new_start);
- this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+ this->priv_destroy_nodes(this->members_.m_start.m_node, new_start.m_node);
 this->members_.m_start = new_start;
 }
 else {
- BOOST_CONTAINER_MOVE_NAMESPACE::move(iterator(last), end(), iterator(first));
+ boost::move(iterator(last), end(), iterator(first));
 iterator new_finish = this->members_.m_finish - n;
 if(!Base::traits_t::trivial_dctr_after_move)
 this->priv_destroy_range(new_finish, this->members_.m_finish);
@@ -992,6 +1291,11 @@
 }
 }

+ //! Effects: Erases all the elements of the deque.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the number of elements in the deque.
 void clear()
 {
 for (index_pointer node = this->members_.m_start.m_node + 1;
@@ -1012,9 +1316,29 @@
 this->members_.m_finish = this->members_.m_start;
 }

+ //! Effects: Tries to deallocate the excess of memory created
+ //! with previous allocations. The size of the deque is unchanged
+ //!
+ //! Throws: If memory allocation throws.
+ //!
+ //! Complexity: Constant.
+ void shrink_to_fit()
+ {
+ //This deque implementation already
+ //deallocates excess nodes when erasing
+ //so there is nothing to do except for
+ //empty deque
+ if(this->empty()){
+ this->priv_clear_map();
+ }
+ }
+
 /// @cond
 private:

+ void priv_range_check(size_type n) const
+ { if (n >= this->size()) BOOST_RETHROW std::out_of_range("deque"); }
+
 iterator priv_insert(const_iterator position, const value_type &x)
 {
 if (position == cbegin()){
@@ -1032,6 +1356,24 @@
 }
 }

+ iterator priv_insert(const_iterator position, BOOST_RV_REF(value_type) mx)
+ {
+ if (position == cbegin()) {
+ this->push_front(boost::move(mx));
+ return begin();
+ }
+ else if (position == cend()) {
+ this->push_back(boost::move(mx));
+ return(end()-1);
+ }
+ else {
+ //Just call more general insert(pos, size, value) and return iterator
+ size_type n = position - begin();
+ this->priv_insert_aux(position, move_it(r_iterator(mx, 1)), move_it(r_iterator()));
+ return iterator(this->begin() + n);
+ }
+ }
+
 void priv_push_front(const value_type &t)
 {
 if(this->priv_push_front_simple_available()){
@@ -1043,6 +1385,17 @@
 }
 }

+ void priv_push_front(BOOST_RV_REF(value_type) t)
+ {
+ if(this->priv_push_front_simple_available()){
+ new(this->priv_push_front_simple_pos())value_type(boost::move(t));
+ this->priv_push_front_simple_commit();
+ }
+ else{
+ this->priv_insert_aux(cbegin(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
+ }
+ }
+
 void priv_push_back(const value_type &t)
 {
 if(this->priv_push_back_simple_available()){
@@ -1054,6 +1407,16 @@
 }
 }

+ void priv_push_back(BOOST_RV_REF(T) t)
+ {
+ if(this->priv_push_back_simple_available()){
+ new(this->priv_push_back_simple_pos())value_type(boost::move(t));
+ this->priv_push_back_simple_commit();
+ }
+ else{
+ this->priv_insert_aux(cend(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
+ }
+ }

 bool priv_push_back_simple_available() const
 {
@@ -1087,7 +1450,7 @@
 void priv_insert_aux(const_iterator pos, InpIt first, InpIt last, std::input_iterator_tag)
 {
 for(;first != last; ++first){
- this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
+ this->insert(pos, boost::move(value_type(*first)));
 }
 }

@@ -1139,7 +1502,7 @@

 template <class Integer>
 void priv_assign_dispatch(Integer n, Integer val, containers_detail::true_)
- { this->priv_fill_assign((size_type) n, val); }
+ { this->priv_fill_assign((size_type) n, (value_type)val); }

 template <class InpIt>
 void priv_assign_dispatch(InpIt first, InpIt last, containers_detail::false_)
@@ -1176,7 +1539,7 @@

 template <class Integer>
 void priv_insert_dispatch(const_iterator pos, Integer n, Integer x, containers_detail::true_)
- { this->priv_fill_insert(pos, (size_type) n, x); }
+ { this->priv_fill_insert(pos, (size_type) n, (value_type)x); }

 template <class InpIt>
 void priv_insert_dispatch(const_iterator pos,InpIt first, InpIt last, containers_detail::false_)
@@ -1215,9 +1578,9 @@
 pos = this->members_.m_start + elemsbefore;
 if (elemsbefore >= difference_type(n)) {
 iterator start_n = this->members_.m_start + difference_type(n);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(this->members_.m_start, start_n, new_start);
+ ::boost::uninitialized_move(this->members_.m_start, start_n, new_start);
 this->members_.m_start = new_start;
- BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
+ boost::move(start_n, pos, old_start);
 interf.copy_all_to(pos - difference_type(n));
 }
 else {
@@ -1225,7 +1588,7 @@
 iterator mid_start = old_start - mid_count;
 interf.uninitialized_copy_some_and_update(mid_start, mid_count, true);
 this->members_.m_start = mid_start;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
 this->members_.m_start = new_start;
 interf.copy_all_to(old_start);
 }
@@ -1238,15 +1601,15 @@
 pos = this->members_.m_finish - elemsafter;
 if (elemsafter >= difference_type(n)) {
 iterator finish_n = this->members_.m_finish - difference_type(n);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
+ ::boost::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
 this->members_.m_finish = new_finish;
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, finish_n, old_finish);
+ boost::move_backward(pos, finish_n, old_finish);
 interf.copy_all_to(pos);
 }
 else {
 interf.uninitialized_copy_some_and_update(old_finish, elemsafter, false);
 this->members_.m_finish += n-elemsafter;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, old_finish, this->members_.m_finish);
+ ::boost::uninitialized_move(pos, old_finish, this->members_.m_finish);
 this->members_.m_finish = new_finish;
 interf.copy_all_to(pos);
 }
@@ -1306,10 +1669,10 @@
 ++cur_node) {
 FwdIt mid = first;
 std::advance(mid, this->s_buffer_size());
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, mid, *cur_node);
+ ::boost::uninitialized_copy_or_move(first, mid, *cur_node);
 first = mid;
 }
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, last, this->members_.m_finish.m_first);
+ ::boost::uninitialized_copy_or_move(first, last, this->members_.m_finish.m_first);
 }
 BOOST_CATCH(...){
 this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node));
@@ -1400,9 +1763,9 @@
 new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2
 + (add_at_front ? nodes_to_add : 0);
 if (new_nstart < this->members_.m_start.m_node)
- BOOST_CONTAINER_MOVE_NAMESPACE::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
 else
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward
+ boost::move_backward
 (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
 }
 else {
@@ -1412,7 +1775,7 @@
 index_pointer new_map = this->priv_allocate_map(new_map_size);
 new_nstart = new_map + (new_map_size - new_num_nodes) / 2
 + (add_at_front ? nodes_to_add : 0);
- BOOST_CONTAINER_MOVE_NAMESPACE::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
 this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);

 this->members_.m_map = new_map;

Modified: sandbox/move/boost/container/detail/adaptive_node_pool_impl.hpp
==============================================================================
--- sandbox/move/boost/container/detail/adaptive_node_pool_impl.hpp (original)
+++ sandbox/move/boost/container/detail/adaptive_node_pool_impl.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -26,22 +26,23 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_POOL_COMMON_HPP
-#include <cassert>
+#include <boost/assert.hpp>
#include <cstddef>

namespace boost {
namespace container {
namespace containers_detail {

-struct hdr_offset_holder
+template<class size_type>
+struct hdr_offset_holder_t
{
- hdr_offset_holder(std::size_t offset = 0)
+ hdr_offset_holder_t(size_type offset = 0)
 : hdr_offset(offset)
 {}
- std::size_t hdr_offset;
+ size_type hdr_offset;
};

-template<class VoidPointer>
+template<class VoidPointer, class SizeType>
struct adaptive_pool_types
{
 typedef VoidPointer void_pointer;
@@ -50,6 +51,8 @@
 , bi::optimize_size<true>
 , bi::constant_time_size<false>
 , bi::link_mode<bi::normal_link> >::type multiset_hook_t;
+
+ typedef hdr_offset_holder_t<SizeType> hdr_offset_holder;

 struct block_info_t
 :
@@ -69,28 +72,31 @@
 const bool is_equal = l.free_nodes.size() == r.free_nodes.size();
 return is_less || (is_equal && (&l < &r));
 }
+
+ friend bool operator ==(const block_info_t &l, const block_info_t &r)
+ { return &l == &r; }
 };
 typedef typename bi::make_multiset
 <block_info_t, bi::base_hook<multiset_hook_t> >::type block_multiset_t;
};

-
-inline std::size_t calculate_alignment
- ( std::size_t overhead_percent, std::size_t real_node_size
- , std::size_t hdr_size, std::size_t hdr_offset_size, std::size_t payload_per_allocation)
+template<class size_type>
+inline size_type calculate_alignment
+ ( size_type overhead_percent, size_type real_node_size
+ , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
{
 //to-do: handle real_node_size != node_size
- const std::size_t divisor = overhead_percent*real_node_size;
- const std::size_t dividend = hdr_offset_size*100;
- std::size_t elements_per_subblock = (dividend - 1)/divisor + 1;
- std::size_t candidate_power_of_2 =
+ const size_type divisor = overhead_percent*real_node_size;
+ const size_type dividend = hdr_offset_size*100;
+ size_type elements_per_subblock = (dividend - 1)/divisor + 1;
+ size_type candidate_power_of_2 =
 upper_power_of_2(elements_per_subblock*real_node_size + hdr_offset_size);
 bool overhead_satisfied = false;
 //Now calculate the wors-case overhead for a subblock
- const std::size_t max_subblock_overhead = hdr_size + payload_per_allocation;
+ const size_type max_subblock_overhead = hdr_size + payload_per_allocation;
 while(!overhead_satisfied){
 elements_per_subblock = (candidate_power_of_2 - max_subblock_overhead)/real_node_size;
- const std::size_t overhead_size = candidate_power_of_2 - elements_per_subblock*real_node_size;
+ const size_type overhead_size = candidate_power_of_2 - elements_per_subblock*real_node_size;
 if(overhead_size*100/candidate_power_of_2 < overhead_percent){
 overhead_satisfied = true;
 }
@@ -101,22 +107,23 @@
 return candidate_power_of_2;
}

+template<class size_type>
inline void calculate_num_subblocks
- (std::size_t alignment, std::size_t real_node_size, std::size_t elements_per_block
- , std::size_t &num_subblocks, std::size_t &real_num_node, std::size_t overhead_percent
- , std::size_t hdr_size, std::size_t hdr_offset_size, std::size_t payload_per_allocation)
+ (size_type alignment, size_type real_node_size, size_type elements_per_block
+ , size_type &num_subblocks, size_type &real_num_node, size_type overhead_percent
+ , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
{
- std::size_t elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
- std::size_t possible_num_subblock = (elements_per_block - 1)/elements_per_subblock + 1;
- std::size_t hdr_subblock_elements = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+ size_type elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
+ size_type possible_num_subblock = (elements_per_block - 1)/elements_per_subblock + 1;
+ size_type hdr_subblock_elements = (alignment - hdr_size - payload_per_allocation)/real_node_size;
 while(((possible_num_subblock-1)*elements_per_subblock + hdr_subblock_elements) < elements_per_block){
 ++possible_num_subblock;
 }
 elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
 bool overhead_satisfied = false;
 while(!overhead_satisfied){
- const std::size_t total_data = (elements_per_subblock*(possible_num_subblock-1) + hdr_subblock_elements)*real_node_size;
- const std::size_t total_size = alignment*possible_num_subblock;
+ const size_type total_data = (elements_per_subblock*(possible_num_subblock-1) + hdr_subblock_elements)*real_node_size;
+ const size_type total_size = alignment*possible_num_subblock;
 if((total_size - total_data)*100/total_size < overhead_percent){
 overhead_satisfied = true;
 }
@@ -138,7 +145,8 @@
 typedef private_adaptive_node_pool_impl this_type;

 typedef typename SegmentManagerBase::void_pointer void_pointer;
- static const std::size_t PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
+ static const typename SegmentManagerBase::
+ size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
 typedef bool_<AlignOnly> IsAlignOnly;
 typedef true_ AlignOnlyTrue;
 typedef false_ AlignOnlyFalse;
@@ -147,15 +155,17 @@
 typedef typename node_slist<void_pointer>::node_t node_t;
 typedef typename node_slist<void_pointer>::node_slist_t free_nodes_t;
 typedef typename SegmentManagerBase::multiallocation_chain multiallocation_chain;
+ typedef typename SegmentManagerBase::size_type size_type;

 private:
- typedef typename adaptive_pool_types<void_pointer>::block_info_t block_info_t;
- typedef typename adaptive_pool_types<void_pointer>::block_multiset_t block_multiset_t;
- typedef typename block_multiset_t::iterator block_iterator;
-
- static const std::size_t MaxAlign = alignment_of<node_t>::value;
- static const std::size_t HdrSize = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
- static const std::size_t HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::block_info_t block_info_t;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::block_multiset_t block_multiset_t;
+ typedef typename block_multiset_t::iterator block_iterator;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::hdr_offset_holder hdr_offset_holder;
+
+ static const size_type MaxAlign = alignment_of<node_t>::value;
+ static const size_type HdrSize = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
+ static const size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;

 public:
@@ -165,20 +175,20 @@
 //!Constructor from a segment manager. Never throws
 private_adaptive_node_pool_impl
 ( segment_manager_base_type *segment_mngr_base
- , std::size_t node_size
- , std::size_t nodes_per_block
- , std::size_t max_free_blocks
+ , size_type node_size
+ , size_type nodes_per_block
+ , size_type max_free_blocks
 , unsigned char overhead_percent
 )
 : m_max_free_blocks(max_free_blocks)
- , m_real_node_size(lcm(node_size, std::size_t(alignment_of<node_t>::value)))
+ , m_real_node_size(lcm(node_size, size_type(alignment_of<node_t>::value)))
 //Round the size to a power of two value.
 //This is the total memory size (including payload) that we want to
 //allocate from the general-purpose allocator
 , m_real_block_alignment
 (AlignOnly ?
 upper_power_of_2(HdrSize + m_real_node_size*nodes_per_block) :
- calculate_alignment( overhead_percent, m_real_node_size
+ calculate_alignment( (size_type)overhead_percent, m_real_node_size
 , HdrSize, HdrOffsetSize, PayloadPerAllocation))
 //This is the real number of nodes per block
 , m_num_subblocks(0)
@@ -195,7 +205,7 @@
 , nodes_per_block
 , m_num_subblocks
 , m_real_num_node
- , overhead_percent
+ , (size_type)overhead_percent
 , HdrSize
 , HdrOffsetSize
 , PayloadPerAllocation);
@@ -206,7 +216,7 @@
 ~private_adaptive_node_pool_impl()
 { priv_clear(); }

- std::size_t get_real_num_node() const
+ size_type get_real_num_node() const
 { return m_real_num_node; }

 //!Returns the segment manager. Never throws
@@ -240,10 +250,10 @@

 //!Allocates n nodes.
 //!Can throw
- multiallocation_chain allocate_nodes(const std::size_t n)
+ multiallocation_chain allocate_nodes(const size_type n)
 {
 multiallocation_chain chain;
- std::size_t i = 0;
+ size_type i = 0;
 try{
 priv_invariants();
 while(i != n){
@@ -252,12 +262,12 @@
 priv_alloc_block(((n - i) - 1)/m_real_num_node + 1);
 }
 free_nodes_t &free_nodes = m_block_multiset.begin()->free_nodes;
- const std::size_t free_nodes_count_before = free_nodes.size();
+ const size_type free_nodes_count_before = free_nodes.size();
 if(free_nodes_count_before == m_real_num_node){
 --m_totally_free_blocks;
 }
- const std::size_t num_elems = ((n-i) < free_nodes_count_before) ? (n-i) : free_nodes_count_before;
- for(std::size_t j = 0; j != num_elems; ++j){
+ const size_type num_elems = ((n-i) < free_nodes_count_before) ? (n-i) : free_nodes_count_before;
+ for(size_type j = 0; j != num_elems; ++j){
 void *new_node = &free_nodes.front();
 free_nodes.pop_front();
 chain.push_back(new_node);
@@ -270,11 +280,11 @@
 }
 }
 catch(...){
- this->deallocate_nodes(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
+ this->deallocate_nodes(boost::move(chain));
 throw;
 }
 priv_invariants();
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
+ return boost::move(chain);
 }

 //!Deallocates a linked list of nodes. Never throws
@@ -289,10 +299,10 @@
 void deallocate_free_blocks()
 { this->priv_deallocate_free_blocks(0); }

- std::size_t num_free_nodes()
+ size_type num_free_nodes()
 {
 typedef typename block_multiset_t::const_iterator citerator;
- std::size_t count = 0;
+ size_type count = 0;
 citerator it (m_block_multiset.begin()), itend(m_block_multiset.end());
 for(; it != itend; ++it){
 count += it->free_nodes.size();
@@ -302,10 +312,10 @@

 void swap(private_adaptive_node_pool_impl &other)
 {
- assert(m_max_free_blocks == other.m_max_free_blocks);
- assert(m_real_node_size == other.m_real_node_size);
- assert(m_real_block_alignment == other.m_real_block_alignment);
- assert(m_real_num_node == other.m_real_num_node);
+ BOOST_ASSERT(m_max_free_blocks == other.m_max_free_blocks);
+ BOOST_ASSERT(m_real_node_size == other.m_real_node_size);
+ BOOST_ASSERT(m_real_block_alignment == other.m_real_block_alignment);
+ BOOST_ASSERT(m_real_num_node == other.m_real_num_node);
 std::swap(mp_segment_mngr_base, other.mp_segment_mngr_base);
 std::swap(m_totally_free_blocks, other.m_totally_free_blocks);
 m_block_multiset.swap(other.m_block_multiset);
@@ -316,7 +326,7 @@
 { this->priv_deallocate_free_blocks(0); }

 private:
- void priv_deallocate_free_blocks(std::size_t max_free_blocks)
+ void priv_deallocate_free_blocks(size_type max_free_blocks)
 {
 priv_invariants();
 //Now check if we've reached the free nodes limit
@@ -326,15 +336,15 @@
 ; m_totally_free_blocks > max_free_blocks
 ; --m_totally_free_blocks
 ){
- assert(!m_block_multiset.empty());
+ BOOST_ASSERT(!m_block_multiset.empty());
 block_iterator it = itend;
 --it;
- assert(it->free_nodes.size() == m_real_num_node);
+ BOOST_ASSERT(it->free_nodes.size() == m_real_num_node);
 m_block_multiset.erase_and_dispose(it, block_destroyer(this));
 }
 }

- void priv_reinsert_nodes_in_block(multiallocation_chain &chain, std::size_t n)
+ void priv_reinsert_nodes_in_block(multiallocation_chain &chain, size_type n)
 {
 block_iterator block_it(m_block_multiset.end());
 while(n--){
@@ -342,7 +352,7 @@
 chain.pop_front();
 priv_invariants();
 block_info_t *block_info = this->priv_block_from_node(pElem);
- assert(block_info->free_nodes.size() < m_real_num_node);
+ BOOST_ASSERT(block_info->free_nodes.size() < m_real_num_node);
 //We put the node at the beginning of the free node list
 node_t * to_deallocate = static_cast<node_t*>(pElem);
 block_info->free_nodes.push_front(*to_deallocate);
@@ -352,7 +362,7 @@
 ++next_block;

 //Cache the free nodes from the block
- std::size_t this_block_free_nodes = this_block->free_nodes.size();
+ size_type this_block_free_nodes = this_block->free_nodes.size();

 if(this_block_free_nodes == 1){
 m_block_multiset.insert(m_block_multiset.begin(), *block_info);
@@ -361,7 +371,7 @@
 block_iterator next_block(this_block);
 ++next_block;
 if(next_block != block_it){
- std::size_t next_free_nodes = next_block->free_nodes.size();
+ size_type next_free_nodes = next_block->free_nodes.size();
 if(this_block_free_nodes > next_free_nodes){
 //Now move the block to the new position
 m_block_multiset.erase(this_block);
@@ -379,12 +389,12 @@

 node_t *priv_take_first_node()
 {
- assert(m_block_multiset.begin() != m_block_multiset.end());
+ BOOST_ASSERT(m_block_multiset.begin() != m_block_multiset.end());
 //We take the first free node the multiset can't be empty
 free_nodes_t &free_nodes = m_block_multiset.begin()->free_nodes;
 node_t *first_node = &free_nodes.front();
- const std::size_t free_nodes_count = free_nodes.size();
- assert(0 != free_nodes_count);
+ const size_type free_nodes_count = free_nodes.size();
+ BOOST_ASSERT(0 != free_nodes_count);
 free_nodes.pop_front();
 if(free_nodes_count == 1){
 m_block_multiset.erase(m_block_multiset.begin());
@@ -412,18 +422,18 @@
 private:
 void do_destroy(typename block_multiset_t::pointer to_deallocate, AlignOnlyTrue)
 {
- std::size_t free_nodes = to_deallocate->free_nodes.size();
+ size_type free_nodes = to_deallocate->free_nodes.size();
 (void)free_nodes;
- assert(free_nodes == mp_impl->m_real_num_node);
+ BOOST_ASSERT(free_nodes == mp_impl->m_real_num_node);
 mp_impl->mp_segment_mngr_base->deallocate(to_deallocate);
 }

 void do_destroy(typename block_multiset_t::pointer to_deallocate, AlignOnlyFalse)
 {
- std::size_t free_nodes = to_deallocate->free_nodes.size();
+ size_type free_nodes = to_deallocate->free_nodes.size();
 (void)free_nodes;
- assert(free_nodes == mp_impl->m_real_num_node);
- assert(0 == to_deallocate->hdr_offset);
+ BOOST_ASSERT(free_nodes == mp_impl->m_real_num_node);
+ BOOST_ASSERT(0 == to_deallocate->hdr_offset);
 hdr_offset_holder *hdr_off_holder = mp_impl->priv_first_subblock_from_block(containers_detail::get_pointer(to_deallocate));
 mp_impl->mp_segment_mngr_base->deallocate(hdr_off_holder);
 }
@@ -444,20 +454,20 @@
 for(++it; it != itend; ++it){
 block_iterator prev(it);
 --prev;
- std::size_t sp = prev->free_nodes.size(),
+ size_type sp = prev->free_nodes.size(),
 si = it->free_nodes.size();
- assert(sp <= si);
+ BOOST_ASSERT(sp <= si);
 (void)sp; (void)si;
 }
 }
 //Check that the total free nodes are correct
 it = m_block_multiset.begin();
 itend = m_block_multiset.end();
- std::size_t total_free_nodes = 0;
+ size_type total_free_nodes = 0;
 for(; it != itend; ++it){
 total_free_nodes += it->free_nodes.size();
 }
- assert(total_free_nodes >= m_totally_free_blocks*m_real_num_node);
+ BOOST_ASSERT(total_free_nodes >= m_totally_free_blocks*m_real_num_node);

 //Check that the total totally free blocks are correct
 it = m_block_multiset.begin();
@@ -466,17 +476,17 @@
 for(; it != itend; ++it){
 total_free += it->free_nodes.size() == m_real_num_node;
 }
- assert(total_free >= m_totally_free_blocks);
+ BOOST_ASSERT(total_free >= m_totally_free_blocks);

 if(!AlignOnly){
 //Check that header offsets are correct
 it = m_block_multiset.begin();
 for(; it != itend; ++it){
 hdr_offset_holder *hdr_off_holder = priv_first_subblock_from_block(&*it);
- for(std::size_t i = 0, max = m_num_subblocks; i < max; ++i){
- assert(hdr_off_holder->hdr_offset == std::size_t(reinterpret_cast<char*>(&*it)- reinterpret_cast<char*>(hdr_off_holder)));
- assert(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
- assert(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
+ for(size_type i = 0, max = m_num_subblocks; i < max; ++i){
+ BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(&*it)- reinterpret_cast<char*>(hdr_off_holder)));
+ BOOST_ASSERT(0 == ((size_type)hdr_off_holder & (m_real_block_alignment - 1)));
+ BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
 hdr_off_holder = reinterpret_cast<hdr_offset_holder *>(reinterpret_cast<char*>(hdr_off_holder) + m_real_block_alignment);
 }
 }
@@ -492,13 +502,13 @@
 #ifndef NDEBUG
 block_iterator it = m_block_multiset.begin();
 block_iterator itend = m_block_multiset.end();
- std::size_t num_free_nodes = 0;
+ size_type num_free_nodes = 0;
 for(; it != itend; ++it){
 //Check for memory leak
- assert(it->free_nodes.size() == m_real_num_node);
+ BOOST_ASSERT(it->free_nodes.size() == m_real_num_node);
 ++num_free_nodes;
 }
- assert(num_free_nodes == m_totally_free_blocks);
+ BOOST_ASSERT(num_free_nodes == m_totally_free_blocks);
 #endif
 //Check for memory leaks
 priv_invariants();
@@ -509,12 +519,12 @@
 block_info_t *priv_block_from_node(void *node, AlignOnlyFalse) const
 {
 hdr_offset_holder *hdr_off_holder =
- reinterpret_cast<hdr_offset_holder*>((std::size_t)node & std::size_t(~(m_real_block_alignment - 1)));
- assert(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
- assert(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
+ reinterpret_cast<hdr_offset_holder*>((std::size_t)node & size_type(~(m_real_block_alignment - 1)));
+ BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
+ BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
 block_info_t *block = reinterpret_cast<block_info_t *>
 (reinterpret_cast<char*>(hdr_off_holder) + hdr_off_holder->hdr_offset);
- assert(block->hdr_offset == 0);
+ BOOST_ASSERT(block->hdr_offset == 0);
 return block;
 }

@@ -530,17 +540,17 @@
 {
 hdr_offset_holder *hdr_off_holder = reinterpret_cast<hdr_offset_holder*>
 (reinterpret_cast<char*>(block) - (m_num_subblocks-1)*m_real_block_alignment);
- assert(hdr_off_holder->hdr_offset == std::size_t(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
- assert(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
- assert(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
+ BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
+ BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
+ BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
 return hdr_off_holder;
 }

 //!Allocates a several blocks of nodes. Can throw
- void priv_alloc_block(std::size_t n, AlignOnlyTrue)
+ void priv_alloc_block(size_type n, AlignOnlyTrue)
 {
- std::size_t real_block_size = m_real_block_alignment - PayloadPerAllocation;
- for(std::size_t i = 0; i != n; ++i){
+ size_type real_block_size = m_real_block_alignment - PayloadPerAllocation;
+ for(size_type i = 0; i != n; ++i){
 //We allocate a new NodeBlock and put it the last
 //element of the tree
 char *mem_address = static_cast<char*>
@@ -554,20 +564,20 @@
 //We initialize all Nodes in Node Block to insert
 //them in the free Node list
 typename free_nodes_t::iterator prev_insert_pos = c_info->free_nodes.before_begin();
- for(std::size_t i = 0; i < m_real_num_node; ++i){
+ for(size_type i = 0; i < m_real_num_node; ++i){
 prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *(node_t*)mem_address);
 mem_address += m_real_node_size;
 }
 }
 }

- void priv_alloc_block(std::size_t n, AlignOnlyFalse)
+ void priv_alloc_block(size_type n, AlignOnlyFalse)
 {
- std::size_t real_block_size = m_real_block_alignment*m_num_subblocks - PayloadPerAllocation;
- std::size_t elements_per_subblock = (m_real_block_alignment - HdrOffsetSize)/m_real_node_size;
- std::size_t hdr_subblock_elements = (m_real_block_alignment - HdrSize - PayloadPerAllocation)/m_real_node_size;
+ size_type real_block_size = m_real_block_alignment*m_num_subblocks - PayloadPerAllocation;
+ size_type elements_per_subblock = (m_real_block_alignment - HdrOffsetSize)/m_real_node_size;
+ size_type hdr_subblock_elements = (m_real_block_alignment - HdrSize - PayloadPerAllocation)/m_real_node_size;

- for(std::size_t i = 0; i != n; ++i){
+ for(size_type i = 0; i != n; ++i){
 //We allocate a new NodeBlock and put it the last
 //element of the tree
 char *mem_address = static_cast<char*>
@@ -579,16 +589,16 @@
 char *hdr_addr = mem_address + m_real_block_alignment*(m_num_subblocks-1);
 block_info_t *c_info = new(hdr_addr)block_info_t;
 //Some structural checks
- assert(static_cast<void*>(&static_cast<hdr_offset_holder*>(c_info)->hdr_offset) ==
+ BOOST_ASSERT(static_cast<void*>(&static_cast<hdr_offset_holder*>(c_info)->hdr_offset) ==
 static_cast<void*>(c_info));
 typename free_nodes_t::iterator prev_insert_pos = c_info->free_nodes.before_begin();
- for( std::size_t subblock = 0, maxsubblock = m_num_subblocks - 1
+ for( size_type subblock = 0, maxsubblock = m_num_subblocks - 1
 ; subblock < maxsubblock
 ; ++subblock, mem_address += m_real_block_alignment){
 //Initialize header offset mark
- new(mem_address) hdr_offset_holder(std::size_t(hdr_addr - mem_address));
+ new(mem_address) hdr_offset_holder(size_type(hdr_addr - mem_address));
 char *pNode = mem_address + HdrOffsetSize;
- for(std::size_t i = 0; i < elements_per_subblock; ++i){
+ for(size_type i = 0; i < elements_per_subblock; ++i){
 prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *new (pNode) node_t);
 pNode += m_real_node_size;
 }
@@ -597,7 +607,7 @@
 char *pNode = hdr_addr + HdrSize;
 //We initialize all Nodes in Node Block to insert
 //them in the free Node list
- for(std::size_t i = 0; i < hdr_subblock_elements; ++i){
+ for(size_type i = 0; i < hdr_subblock_elements; ++i){
 prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *new (pNode) node_t);
 pNode += m_real_node_size;
 }
@@ -608,25 +618,25 @@
 }

 //!Allocates a block of nodes. Can throw std::bad_alloc
- void priv_alloc_block(std::size_t n)
+ void priv_alloc_block(size_type n)
 { return priv_alloc_block(n, IsAlignOnly()); }

 private:
 typedef typename boost::pointer_to_other
 <void_pointer, segment_manager_base_type>::type segment_mngr_base_ptr_t;
- const std::size_t m_max_free_blocks;
- const std::size_t m_real_node_size;
+ const size_type m_max_free_blocks;
+ const size_type m_real_node_size;
 //Round the size to a power of two value.
 //This is the total memory size (including payload) that we want to
 //allocate from the general-purpose allocator
- const std::size_t m_real_block_alignment;
- std::size_t m_num_subblocks;
+ const size_type m_real_block_alignment;
+ size_type m_num_subblocks;
 //This is the real number of nodes per block
 //const
- std::size_t m_real_num_node;
+ size_type m_real_num_node;
 segment_mngr_base_ptr_t mp_segment_mngr_base; //Segment manager
 block_multiset_t m_block_multiset; //Intrusive block list
- std::size_t m_totally_free_blocks; //Free blocks
+ size_type m_totally_free_blocks; //Free blocks
};

} //namespace containers_detail {

Modified: sandbox/move/boost/container/detail/advanced_insert_int.hpp
==============================================================================
--- sandbox/move/boost/container/detail/advanced_insert_int.hpp (original)
+++ sandbox/move/boost/container/detail/advanced_insert_int.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -17,11 +17,10 @@

#include "config_begin.hpp"
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <iterator> //std::iterator_traits
-#include <algorithm> //std::copy, std::uninitialized_copy
#include <new> //placement new
-#include <cassert>
+#include <boost/assert.hpp>

namespace boost { namespace container { namespace containers_detail {

@@ -51,21 +50,21 @@
 {}

 virtual void copy_all_to(Iterator p)
- { std::copy(first_, last_, p); }
+ { ::boost::copy_or_move(first_, last_, p); }

 virtual void uninitialized_copy_all_to(Iterator p)
- { ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first_, last_, p); }
+ { ::boost::uninitialized_copy_or_move(first_, last_, p); }

 virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
 {
 FwdIt mid = first_;
 std::advance(mid, division_count);
 if(first_n){
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first_, mid, pos);
+ ::boost::uninitialized_copy_or_move(first_, mid, pos);
 first_ = mid;
 }
 else{
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(mid, last_, pos);
+ ::boost::uninitialized_copy_or_move(mid, last_, pos);
 last_ = mid;
 }
 }
@@ -75,11 +74,11 @@
 FwdIt mid = first_;
 std::advance(mid, division_count);
 if(first_n){
- std::copy(first_, mid, pos);
+ ::boost::copy_or_move(first_, mid, pos);
 first_ = mid;
 }
 else{
- std::copy(mid, last_, pos);
+ ::boost::copy_or_move(mid, last_, pos);
 last_ = mid;
 }
 }
@@ -99,7 +98,7 @@

 void uninitialized_copy_impl(Iterator p, const SizeType n)
 {
- assert(n <= count_);
+ BOOST_ASSERT(n <= count_);
 Iterator orig_p = p;
 SizeType i = 0;
 try{
@@ -121,7 +120,7 @@

 virtual void copy_all_to(Iterator)
 { //This should never be called with any count
- assert(count_ == 0);
+ BOOST_ASSERT(count_ == 0);
 }

 virtual void uninitialized_copy_all_to(Iterator p)
@@ -134,7 +133,7 @@
 new_count = division_count;
 }
 else{
- assert(difference_type(count_)>= division_count);
+ BOOST_ASSERT(difference_type(count_)>= division_count);
 new_count = count_ - division_count;
 }
 this->uninitialized_copy_impl(pos, new_count);
@@ -142,17 +141,17 @@

 virtual void copy_some_and_update(Iterator , difference_type division_count, bool first_n)
 {
- assert(count_ == 0);
+ BOOST_ASSERT(count_ == 0);
 SizeType new_count;
 if(first_n){
 new_count = division_count;
 }
 else{
- assert(difference_type(count_)>= division_count);
+ BOOST_ASSERT(difference_type(count_)>= division_count);
 new_count = count_ - division_count;
 }
 //This function should never called with a count different to zero
- assert(new_count == 0);
+ BOOST_ASSERT(new_count == 0);
 (void)new_count;
 }

@@ -164,7 +163,8 @@
#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP
+#include <boost/move/move.hpp>
#include <typeinfo>
//#include <iostream> //For debugging purposes

@@ -181,7 +181,8 @@
 typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;

 explicit advanced_insert_aux_emplace(Args&&... args)
- : args_(args...), used_(false)
+ : args_(args...)
+ , used_(false)
 {}

 ~advanced_insert_aux_emplace()
@@ -204,7 +205,7 @@
 void priv_copy_all_to(const index_tuple<IdxPack...>&, Iterator p)
 {
 if(!used_){
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T (BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...));
+ *p = boost::move(T (::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
 used_ = true;
 }
 }
@@ -213,7 +214,7 @@
 void priv_uninitialized_copy_all_to(const index_tuple<IdxPack...>&, Iterator p)
 {
 if(!used_){
- new(containers_detail::get_pointer(&*p))T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...);
+ new(containers_detail::get_pointer(&*p))T(::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...);
 used_ = true;
 }
 }
@@ -221,10 +222,10 @@
 template<int ...IdxPack>
 void priv_uninitialized_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, difference_type division_count, bool first_n)
 {
- assert(division_count <=1);
+ BOOST_ASSERT(division_count <=1);
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
- new(containers_detail::get_pointer(&*p))T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...);
+ new(containers_detail::get_pointer(&*p))T(::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...);
 used_ = true;
 }
 }
@@ -233,15 +234,15 @@
 template<int ...IdxPack>
 void priv_copy_some_and_update(const index_tuple<IdxPack...>&, Iterator p, difference_type division_count, bool first_n)
 {
- assert(division_count <=1);
+ BOOST_ASSERT(division_count <=1);
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...));
+ *p = boost::move(T(::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
 used_ = true;
 }
 }
 }
- tuple<Args&&...> args_;
+ tuple<Args&...> args_;
 bool used_;
};

@@ -273,7 +274,7 @@
 {
 if(!used_){
 value_init<T>v;
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
+ *p = boost::move(v.m_t);
 used_ = true;
 }
 }
@@ -288,7 +289,7 @@

 virtual void uninitialized_copy_some_and_update(Iterator p, difference_type division_count, bool first_n)
 {
- assert(division_count <=1);
+ BOOST_ASSERT(division_count <=1);
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
 new(containers_detail::get_pointer(&*p))T();
@@ -299,11 +300,11 @@

 virtual void copy_some_and_update(Iterator p, difference_type division_count, bool first_n)
 {
- assert(division_count <=1);
+ BOOST_ASSERT(division_count <=1);
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
 value_init<T>v;
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
+ *p = boost::move(v.m_t);
 used_ = true;
 }
 }
@@ -327,7 +328,7 @@
 { \
 if(!used_){ \
 T v(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_MEMBER_FORWARD, _)); \
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v); \
+ *p = boost::move(v); \
 used_ = true; \
 } \
 } \
@@ -344,7 +345,7 @@
 virtual void uninitialized_copy_some_and_update \
 (Iterator p, difference_type division_count, bool first_n) \
 { \
- assert(division_count <=1); \
+ BOOST_ASSERT(division_count <=1); \
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){ \
 if(!used_){ \
 new(containers_detail::get_pointer(&*p))T \
@@ -357,11 +358,11 @@
 virtual void copy_some_and_update \
 (Iterator p, difference_type division_count, bool first_n) \
 { \
- assert(division_count <=1); \
+ BOOST_ASSERT(division_count <=1); \
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){ \
 if(!used_){ \
 T v(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_MEMBER_FORWARD, _)); \
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v); \
+ *p = boost::move(v); \
 used_ = true; \
 } \
 } \

Modified: sandbox/move/boost/container/detail/algorithms.hpp
==============================================================================
--- sandbox/move/boost/container/detail/algorithms.hpp (original)
+++ sandbox/move/boost/container/detail/algorithms.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -77,8 +77,8 @@
::new((void*)dest)T();
}

-template<class T, class U, class E>
-inline void construct_in_place(T *dest, emplace_iterator<U, E> ei)
+template<class T, class U, class E, class D>
+inline void construct_in_place(T *dest, emplace_iterator<U, E, D> ei)
{
ei.construct_in_place(dest);
}

Modified: sandbox/move/boost/container/detail/config_begin.hpp
==============================================================================
--- sandbox/move/boost/container/detail/config_begin.hpp (original)
+++ sandbox/move/boost/container/detail/config_begin.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -12,19 +12,6 @@
#include <boost/config.hpp>

//#define BOOST_CONTAINER_IN_INTERPROCESS
-//#define BOOST_MOVE_IN_INTERPROCESS
-
-#ifdef BOOST_MOVE_IN_INTERPROCESS
-
-#define INCLUDE_BOOST_CONTAINER_MOVE_HPP <boost/interprocess/detail/move.hpp >
-#define BOOST_CONTAINER_MOVE_NAMESPACE boost::interprocess
-
-#else
-
-#define INCLUDE_BOOST_CONTAINER_MOVE_HPP <boost/move/move.hpp >
-#define BOOST_CONTAINER_MOVE_NAMESPACE boost
-
-#endif

#ifdef BOOST_CONTAINER_IN_INTERPROCESS

@@ -62,6 +49,7 @@
#define INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP <boost/interprocess/containers/container/detail/utilities.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VALUE_INIT_HPP <boost/interprocess/containers/container/detail/value_init.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP <boost/interprocess/containers/container/detail/variadic_templates_tools.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP <boost/interprocess/containers/container/detail/stored_ref.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP <boost/interprocess/containers/container/detail/version_type.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP <boost/interprocess/containers/container/detail/workaround.hpp>

@@ -102,6 +90,7 @@
#define INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP <boost/container/detail/utilities.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VALUE_INIT_HPP <boost/container/detail/value_init.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP <boost/container/detail/variadic_templates_tools.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP <boost/container/detail/stored_ref.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP <boost/container/detail/version_type.hpp>
#define INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP <boost/container/detail/workaround.hpp>

Modified: sandbox/move/boost/container/detail/destroyers.hpp
==============================================================================
--- sandbox/move/boost/container/detail/destroyers.hpp (original)
+++ sandbox/move/boost/container/detail/destroyers.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -89,7 +89,7 @@
 {
 if(!m_p) return;
 value_type *raw_ptr = containers_detail::get_pointer(m_p);
- for(std::size_t i = 0; i < m_n; ++i, ++raw_ptr)
+ for(size_type i = 0; i < m_n; ++i, ++raw_ptr)
 raw_ptr->~value_type();
 }
};

Modified: sandbox/move/boost/container/detail/flat_tree.hpp
==============================================================================
--- sandbox/move/boost/container/detail/flat_tree.hpp (original)
+++ sandbox/move/boost/container/detail/flat_tree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -42,7 +42,7 @@
#include <utility>

#include <boost/type_traits/has_trivial_destructor.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>

#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
@@ -108,7 +108,7 @@
 : public value_compare
 {
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(Data)
+ BOOST_COPYABLE_AND_MOVABLE(Data)
 public:
 Data(const Data &d)
 : value_compare(d), m_vect(d.m_vect)
@@ -125,17 +125,17 @@
 const allocator_t &alloc)
 : value_compare(comp), m_vect(alloc){}

- Data& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(Data) d)
+ Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
 {
 this->value_compare::operator=(d);
 m_vect = d.m_vect;
 return *this;
 }

- Data& operator=(BOOST_MOVE_MACRO_RV_REF(Data) d)
+ Data& operator=(BOOST_RV_REF(Data) d)
 {
- this->value_compare::operator=(BOOST_CONTAINER_MOVE_NAMESPACE::move(static_cast<value_compare &>(d)));
- m_vect = BOOST_CONTAINER_MOVE_NAMESPACE::move(d.m_vect);
+ this->value_compare::operator=(boost::move(static_cast<value_compare &>(d)));
+ m_vect = boost::move(d.m_vect);
 return *this;
 }

@@ -143,7 +143,7 @@
 };

 Data m_data;
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_tree)
+ BOOST_COPYABLE_AND_MOVABLE(flat_tree)

 public:

@@ -174,8 +174,8 @@
 : m_data(x.m_data, x.m_data.m_vect)
 { }

- flat_tree(BOOST_MOVE_MACRO_RV_REF(flat_tree) x)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_data))
+ flat_tree(BOOST_RV_REF(flat_tree) x)
+ : m_data(boost::move(x.m_data))
 { }

 template <class InputIterator>
@@ -188,11 +188,11 @@
 ~flat_tree()
 { }

- flat_tree& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_tree) x)
+ flat_tree& operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
 { m_data = x.m_data; return *this; }

- flat_tree& operator=(BOOST_MOVE_MACRO_RV_REF(flat_tree) mx)
- { m_data = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_data); return *this; }
+ flat_tree& operator=(BOOST_RV_REF(flat_tree) mx)
+ { m_data = boost::move(mx.m_data); return *this; }

 public:
 // accessors:
@@ -275,12 +275,12 @@
 return ret;
 }

- std::pair<iterator,bool> insert_unique(BOOST_MOVE_MACRO_RV_REF(value_type) val)
+ std::pair<iterator,bool> insert_unique(BOOST_RV_REF(value_type) val)
 {
 insert_commit_data data;
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
 }
 return ret;
 }
@@ -293,10 +293,10 @@
 return i;
 }

- iterator insert_equal(BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_equal(BOOST_RV_REF(value_type) mval)
 {
 iterator i = this->upper_bound(KeyOfValue()(mval));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ i = this->m_data.m_vect.insert(i, boost::move(mval));
 return i;
 }

@@ -310,12 +310,12 @@
 return ret.first;
 }

- iterator insert_unique(const_iterator pos, BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_unique(const_iterator pos, BOOST_RV_REF(value_type) mval)
 {
 insert_commit_data data;
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(pos, mval, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ ret.first = priv_insert_commit(data, boost::move(mval));
 }
 return ret.first;
 }
@@ -327,11 +327,11 @@
 return priv_insert_commit(data, val);
 }

- iterator insert_equal(const_iterator pos, BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_equal(const_iterator pos, BOOST_RV_REF(value_type) mval)
 {
 insert_commit_data data;
 priv_insert_equal_prepare(pos, mval, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ return priv_insert_commit(data, boost::move(mval));
 }

 template <class InIt>
@@ -354,12 +354,12 @@
 template <class... Args>
 iterator emplace_unique(Args&&... args)
 {
- value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type && val = value_type(boost::forward<Args>(args)...);
 insert_commit_data data;
 std::pair<iterator,bool> ret =
 priv_insert_unique_prepare(val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
 }
 return ret.first;
 }
@@ -367,11 +367,11 @@
 template <class... Args>
 iterator emplace_hint_unique(const_iterator hint, Args&&... args)
 {
- value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type && val = value_type(boost::forward<Args>(args)...);
 insert_commit_data data;
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
 }
 return ret.first;
 }
@@ -379,19 +379,19 @@
 template <class... Args>
 iterator emplace_equal(Args&&... args)
 {
- value_type &&val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type &&val = value_type(boost::forward<Args>(args)...);
 iterator i = this->upper_bound(KeyOfValue()(val));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ i = this->m_data.m_vect.insert(i, boost::move(val));
 return i;
 }

 template <class... Args>
 iterator emplace_hint_equal(const_iterator hint, Args&&... args)
 {
- value_type &&val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type &&val = value_type(boost::forward<Args>(args)...);
 insert_commit_data data;
 priv_insert_equal_prepare(hint, val, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ return priv_insert_commit(data, boost::move(val));
 }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -404,7 +404,7 @@
 std::pair<iterator,bool> ret =
 priv_insert_unique_prepare(val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
 }
 return ret.first;
 }
@@ -416,7 +416,7 @@
 insert_commit_data data;
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
 }
 return ret.first;
 }
@@ -426,7 +426,7 @@
 containers_detail::value_init<value_type> vval;
 value_type &val = vval.m_t;
 iterator i = this->upper_bound(KeyOfValue()(val));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ i = this->m_data.m_vect.insert(i, boost::move(val));
 return i;
 }

@@ -436,7 +436,7 @@
 value_type &val = vval.m_t;
 insert_commit_data data;
 priv_insert_equal_prepare(hint, val, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
+ return priv_insert_commit(data, boost::move(val));
 }

 #define BOOST_PP_LOCAL_MACRO(n) \
@@ -447,7 +447,7 @@
 insert_commit_data data; \
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data); \
 if(ret.second){ \
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
+ ret.first = priv_insert_commit(data, boost::move(val)); \
 } \
 return ret.first; \
 } \
@@ -460,7 +460,7 @@
 insert_commit_data data; \
 std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data); \
 if(ret.second){ \
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
+ ret.first = priv_insert_commit(data, boost::move(val)); \
 } \
 return ret.first; \
 } \
@@ -470,7 +470,7 @@
 { \
 value_type val(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 iterator i = this->upper_bound(KeyOfValue()(val)); \
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
+ i = this->m_data.m_vect.insert(i, boost::move(val)); \
 return i; \
 } \
 \
@@ -481,7 +481,7 @@
 value_type val(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 insert_commit_data data; \
 priv_insert_equal_prepare(hint, val, data); \
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
+ return priv_insert_commit(data, boost::move(val)); \
 } \
 //!
 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINERS_MAX_CONSTRUCTOR_PARAMETERS)
@@ -677,11 +677,11 @@

 template<class Convertible>
 iterator priv_insert_commit
- (insert_commit_data &commit_data, BOOST_MOVE_MACRO_FWD_REF(Convertible) convertible)
+ (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
 {
 return this->m_data.m_vect.insert
 ( commit_data.position
- , BOOST_CONTAINER_MOVE_NAMESPACE::forward<Convertible>(convertible));
+ , boost::forward<Convertible>(convertible));
 }

 template <class RanIt>

Modified: sandbox/move/boost/container/detail/iterators.hpp
==============================================================================
--- sandbox/move/boost/container/detail/iterators.hpp (original)
+++ sandbox/move/boost/container/detail/iterators.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -20,10 +20,11 @@

#include "config_begin.hpp"
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP
#else
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif
@@ -58,6 +59,16 @@
 return result;
 }

+ constant_iterator& operator--()
+ { decrement(); return *this; }
+
+ constant_iterator operator--(int)
+ {
+ constant_iterator result (*this);
+ decrement();
+ return result;
+ }
+
 friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
 { return i.equal(i2); }

@@ -102,6 +113,9 @@
 const T& operator*() const
 { return dereference(); }

+ const T& operator[] (Difference n) const
+ { return dereference(); }
+
 const T* operator->() const
 { return &(dereference()); }

@@ -156,6 +170,16 @@
 return result;
 }

+ default_construct_iterator& operator--()
+ { decrement(); return *this; }
+
+ default_construct_iterator operator--(int)
+ {
+ default_construct_iterator result (*this);
+ decrement();
+ return result;
+ }
+
 friend bool operator== (const default_construct_iterator& i, const default_construct_iterator& i2)
 { return i.equal(i2); }

@@ -203,6 +227,9 @@
 const T* operator->() const
 { return &(dereference()); }

+ const T& operator[] (Difference n) const
+ { return dereference(); }
+
 private:
 Difference m_num;

@@ -255,6 +282,16 @@
 return result;
 }

+ this_type& operator--()
+ { increment(); return *this; }
+
+ this_type operator--(int)
+ {
+ this_type result (*this);
+ increment();
+ return result;
+ }
+
 friend bool operator== (const this_type& i, const this_type& i2)
 { return i.equal(i2); }

@@ -299,6 +336,9 @@
 T& operator*() const
 { return dereference(); }

+ T& operator[] (Difference n) const
+ { return dereference(); }
+
 T *operator->() const
 { return &(dereference()); }

@@ -328,14 +368,15 @@
 { return m_num - other.m_num; }
};

-template <class T, class E>
+template <class T, class E, class Difference /*= std::ptrdiff_t*/>
class emplace_iterator
 : public std::iterator
- <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
+ <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
 typedef emplace_iterator this_type;

 public:
+ typedef Difference difference_type;
 explicit emplace_iterator(E&e)
 : m_num(1), m_pe(&e){}

@@ -352,6 +393,16 @@
 return result;
 }

+ this_type& operator--()
+ { decrement(); return *this; }
+
+ this_type operator--(int)
+ {
+ this_type result (*this);
+ decrement();
+ return result;
+ }
+
 friend bool operator== (const this_type& i, const this_type& i2)
 { return i.equal(i2); }

@@ -370,32 +421,35 @@
 friend bool operator>= (const this_type& i, const this_type& i2)
 { return !(i < i2); }

- friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
+ friend difference_type operator- (const this_type& i, const this_type& i2)
 { return i2.distance_to(i); }

 //Arithmetic
- this_type& operator+=(std::ptrdiff_t off)
+ this_type& operator+=(difference_type off)
 { this->advance(off); return *this; }

- this_type operator+(std::ptrdiff_t off) const
+ this_type operator+(difference_type off) const
 {
 this_type other(*this);
 other.advance(off);
 return other;
 }

- friend this_type operator+(std::ptrdiff_t off, const this_type& right)
+ friend this_type operator+(difference_type off, const this_type& right)
 { return right + off; }

- this_type& operator-=(std::ptrdiff_t off)
+ this_type& operator-=(difference_type off)
 { this->advance(-off); return *this; }

- this_type operator-(std::ptrdiff_t off) const
+ this_type operator-(difference_type off) const
 { return *this + (-off); }

 const T& operator*() const
 { return dereference(); }

+ const T& operator[](difference_type) const
+ { return dereference(); }
+
 const T* operator->() const
 { return &(dereference()); }

@@ -403,7 +457,7 @@
 { (*m_pe)(ptr); }

 private:
- std::ptrdiff_t m_num;
+ difference_type m_num;
 E * m_pe;

 void increment()
@@ -424,11 +478,11 @@
 return dummy;
 }

- void advance(std::ptrdiff_t n)
+ void advance(difference_type n)
 { m_num -= n; }

- std::ptrdiff_t distance_to(const this_type &other)const
- { return m_num - other.m_num; }
+ difference_type distance_to(const this_type &other)const
+ { return difference_type(m_num - other.m_num); }
};

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -447,9 +501,9 @@

 template<int ...IdxPack>
 void inplace_impl(T* ptr, const containers_detail::index_tuple<IdxPack...>&)
- { ::new(ptr) T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(containers_detail::get<IdxPack>(args_))...); }
+ { ::new(ptr) T(containers_detail::stored_ref<Args>::forward(containers_detail::get<IdxPack>(args_))...); }

- containers_detail::tuple<Args&&...> args_;
+ containers_detail::tuple<Args&...> args_;
};

#else

Modified: sandbox/move/boost/container/detail/math_functions.hpp
==============================================================================
--- sandbox/move/boost/container/detail/math_functions.hpp (original)
+++ sandbox/move/boost/container/detail/math_functions.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,7 @@
#ifndef BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP
#define BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP

+#include "config_begin.hpp"
#include <climits>
#include <boost/static_assert.hpp>

@@ -107,4 +108,6 @@
} // namespace container
} // namespace boost

+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP
+
#endif

Modified: sandbox/move/boost/container/detail/mpl.hpp
==============================================================================
--- sandbox/move/boost/container/detail/mpl.hpp (original)
+++ sandbox/move/boost/container/detail/mpl.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -62,6 +62,9 @@
template <class Cond, class T = void>
struct disable_if : public enable_if_c<!Cond::value, T> {};

+template <bool B, class T = void>
+struct disable_if_c : public enable_if_c<!B, T> {};
+
template <class T, class U>
class is_convertible
{

Modified: sandbox/move/boost/container/detail/multiallocation_chain.hpp
==============================================================================
--- sandbox/move/boost/container/detail/multiallocation_chain.hpp (original)
+++ sandbox/move/boost/container/detail/multiallocation_chain.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -18,7 +18,8 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP
#include <boost/intrusive/slist.hpp>
#include <boost/pointer_to_other.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace container {
@@ -32,34 +33,39 @@
 ,bi::link_mode<bi::normal_link>
> node;

+ typedef typename boost::pointer_to_other<VoidPointer, char>::type char_ptr;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+
 typedef bi::slist< node
 , bi::linear<true>
 , bi::cache_last<true>
+ , bi::size_type<typename boost::make_unsigned<difference_type>::type>
> slist_impl_t;
 slist_impl_t slist_impl_;

 static node & to_node(VoidPointer p)
 { return *static_cast<node*>(static_cast<void*>(containers_detail::get_pointer(p))); }

- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)

 public:

 typedef VoidPointer void_pointer;
 typedef typename slist_impl_t::iterator iterator;
+ typedef typename slist_impl_t::size_type size_type;

 basic_multiallocation_chain()
 : slist_impl_()
 {}

- basic_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
+ basic_multiallocation_chain(BOOST_RV_REF(basic_multiallocation_chain) other)
 : slist_impl_()
 { slist_impl_.swap(other.slist_impl_); }

- basic_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
+ basic_multiallocation_chain& operator=(BOOST_RV_REF(basic_multiallocation_chain) other)
 {
- basic_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
+ basic_multiallocation_chain tmp(boost::move(other));
 this->swap(tmp);
 return *this;
 }
@@ -67,7 +73,7 @@
 bool empty() const
 { return slist_impl_.empty(); }

- std::size_t size() const
+ size_type size() const
 { return slist_impl_.size(); }

 iterator before_begin()
@@ -103,7 +109,7 @@
 void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
 { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end); }

- void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
+ void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
 { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n); }

 void splice_after(iterator after_this, basic_multiallocation_chain &x)
@@ -112,7 +118,7 @@
 void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
 { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end)); }

- void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
+ void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
 { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end), n); }

 void swap(basic_multiallocation_chain &x)
@@ -144,7 +150,7 @@
class transform_multiallocation_chain
{
 private:
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)

 MultiallocationChain holder_;
 typedef typename MultiallocationChain::void_pointer void_pointer;
@@ -160,22 +166,23 @@
 typedef transform_iterator
 < typename MultiallocationChain::iterator
 , containers_detail::cast_functor <T> > iterator;
+ typedef typename MultiallocationChain::size_type size_type;

 transform_multiallocation_chain()
 : holder_()
 {}

- transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
+ transform_multiallocation_chain(BOOST_RV_REF(transform_multiallocation_chain) other)
 : holder_()
 { this->swap(other); }

- transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(MultiallocationChain) other)
- : holder_(BOOST_CONTAINER_MOVE_NAMESPACE::move(other))
+ transform_multiallocation_chain(BOOST_RV_REF(MultiallocationChain) other)
+ : holder_(boost::move(other))
 {}

- transform_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
+ transform_multiallocation_chain& operator=(BOOST_RV_REF(transform_multiallocation_chain) other)
 {
- transform_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
+ transform_multiallocation_chain tmp(boost::move(other));
 this->swap(tmp);
 return *this;
 }
@@ -186,10 +193,10 @@
 void swap(transform_multiallocation_chain &other_chain)
 { holder_.swap(other_chain.holder_); }

- void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
+ void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
 { holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n); }

- void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
+ void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
 { holder_.incorporate_after(after_this.base(), begin, before_end, n); }

 void pop_front()
@@ -213,7 +220,7 @@
 iterator last()
 { return iterator(holder_.last()); }

- std::size_t size() const
+ size_type size() const
 { return holder_.size(); }

 void clear()
@@ -230,7 +237,7 @@

 MultiallocationChain extract_multiallocation_chain()
 {
- return MultiallocationChain(BOOST_CONTAINER_MOVE_NAMESPACE::move(holder_));
+ return MultiallocationChain(boost::move(holder_));
 }
};

Modified: sandbox/move/boost/container/detail/node_alloc_holder.hpp
==============================================================================
--- sandbox/move/boost/container/detail/node_alloc_holder.hpp (original)
+++ sandbox/move/boost/container/detail/node_alloc_holder.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -21,7 +21,7 @@
#include <utility>
#include <functional>

-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/intrusive/options.hpp>

#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
@@ -60,7 +60,7 @@
 void priv_deallocate(allocator_v2)
 { m_alloc.deallocate_one(m_ptr); }

- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)

 public:

@@ -74,7 +74,7 @@
 ~scoped_deallocator()
 { if (m_ptr)priv_deallocate(alloc_version()); }

- scoped_deallocator(BOOST_MOVE_MACRO_RV_REF(scoped_deallocator) o)
+ scoped_deallocator(BOOST_RV_REF(scoped_deallocator) o)
 : m_ptr(o.m_ptr), m_alloc(o.m_alloc)
 { o.release(); }

@@ -128,7 +128,7 @@
 ~allocator_multialloc_chain_node_deallocator()
 {
 if(!c_.empty())
- a_.deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(c_));
+ a_.deallocate_individual(boost::move(c_));
 }
};

@@ -177,7 +177,7 @@
 typedef allocator_destroyer<NodeAlloc> Destroyer;

 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(node_alloc_holder)
+ BOOST_COPYABLE_AND_MOVABLE(node_alloc_holder)

 public:

@@ -189,14 +189,14 @@
 : members_(other.node_alloc())
 {}

- node_alloc_holder(BOOST_MOVE_MACRO_RV_REF(node_alloc_holder) other)
- : members_(BOOST_CONTAINER_MOVE_NAMESPACE::move(other.node_alloc()))
+ node_alloc_holder(BOOST_RV_REF(node_alloc_holder) other)
+ : members_(boost::move(other.node_alloc()))
 { this->swap(other); }

- node_alloc_holder & operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(node_alloc_holder) other)
+ node_alloc_holder & operator=(BOOST_COPY_ASSIGN_REF(node_alloc_holder) other)
 { members_.assign(other.node_alloc()); }

- node_alloc_holder & operator=(BOOST_MOVE_MACRO_RV_REF(node_alloc_holder) other)
+ node_alloc_holder & operator=(BOOST_RV_REF(node_alloc_holder) other)
 { members_.assign(other.node_alloc()); }

 template<class Pred>
@@ -205,7 +205,7 @@
 {}

 template<class Pred>
- node_alloc_holder(BOOST_MOVE_MACRO_RV_REF(ValAlloc) a, const Pred &c)
+ node_alloc_holder(BOOST_RV_REF(ValAlloc) a, const Pred &c)
 : members_(a, typename ICont::value_compare(c))
 {}

@@ -240,7 +240,7 @@

 template<class Convertible1, class Convertible2>
 static void construct(const NodePtr &ptr,
- BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, Convertible1, Convertible2) value)
+ BOOST_RV_REF_2_TEMPL_ARGS(std::pair, Convertible1, Convertible2) value)
 {
 typedef typename Node::hook_type hook_type;
 typedef typename Node::value_type::first_type first_type;
@@ -251,9 +251,9 @@
 new(static_cast<hook_type*>(nodeptr))hook_type();
 //Now construct pair members_holder
 value_type *valueptr = &nodeptr->get_data();
- new((void*)&valueptr->first) first_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(value.first));
+ new((void*)&valueptr->first) first_type(boost::move(value.first));
 BOOST_TRY{
- new((void*)&valueptr->second) second_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(value.second));
+ new((void*)&valueptr->second) second_type(boost::move(value.second));
 }
 BOOST_CATCH(...){
 valueptr->first.~first_type();
@@ -275,14 +275,14 @@

 template<class ...Args>
 static void construct(const NodePtr &ptr, Args &&...args)
- { new((void*)containers_detail::get_pointer(ptr)) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { new((void*)containers_detail::get_pointer(ptr)) Node(boost::forward<Args>(args)...); }

 template<class ...Args>
 NodePtr create_node(Args &&...args)
 {
 NodePtr p = this->allocate_one();
 Deallocator node_deallocator(p, this->node_alloc());
- self_t::construct(p, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ self_t::construct(p, boost::forward<Args>(args)...);
 node_deallocator.release();
 return (p);
 }
@@ -383,7 +383,7 @@
 if(constructed){
 this->destroy(p);
 }
- this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(mem));
+ this->node_alloc().deallocate_individual(boost::move(mem));
 BOOST_RETHROW
 }
 BOOST_CATCH_END
@@ -399,9 +399,9 @@
 typename NodeAlloc::multiallocation_chain chain;
 allocator_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
 this->icont().clear_and_dispose(builder);
- BOOST_STATIC_ASSERT((::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<typename NodeAlloc::multiallocation_chain>::value == true));
+ //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
 if(!chain.empty())
- this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
+ this->node_alloc().deallocate_individual(boost::move(chain));
 }

 icont_iterator erase_range(icont_iterator first, icont_iterator last, allocator_v1)

Modified: sandbox/move/boost/container/detail/node_pool_impl.hpp
==============================================================================
--- sandbox/move/boost/container/detail/node_pool_impl.hpp (original)
+++ sandbox/move/boost/container/detail/node_pool_impl.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -26,7 +26,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_POOL_COMMON_HPP
-#include <cassert>
+#include <boost/assert.hpp>
#include <cstddef>
#include <functional> //std::unary_function

@@ -49,6 +49,7 @@
 typedef typename node_slist<void_pointer>::node_t node_t;
 typedef typename node_slist<void_pointer>::node_slist_t free_nodes_t;
 typedef typename SegmentManagerBase::multiallocation_chain multiallocation_chain;
+ typedef typename SegmentManagerBase::size_type size_type;

 private:
 typedef typename bi::make_slist
@@ -61,9 +62,9 @@
 typedef SegmentManagerBase segment_manager_base_type;

 //!Constructor from a segment manager. Never throws
- private_node_pool_impl(segment_manager_base_type *segment_mngr_base, std::size_t node_size, std::size_t nodes_per_block)
+ private_node_pool_impl(segment_manager_base_type *segment_mngr_base, size_type node_size, size_type nodes_per_block)
 : m_nodes_per_block(nodes_per_block)
- , m_real_node_size(lcm(node_size, std::size_t(alignment_of<node_t>::value)))
+ , m_real_node_size(lcm(node_size, size_type(alignment_of<node_t>::value)))
 //General purpose allocator
 , mp_segment_mngr_base(segment_mngr_base)
 , m_blocklist()
@@ -76,7 +77,7 @@
 ~private_node_pool_impl()
 { this->purge_blocks(); }

- std::size_t get_real_num_node() const
+ size_type get_real_num_node() const
 { return m_nodes_per_block; }

 //!Returns the segment manager. Never throws
@@ -91,10 +92,10 @@
 { priv_dealloc_node(ptr); }

 //!Allocates a singly linked list of n nodes ending in null pointer.
- multiallocation_chain allocate_nodes(const std::size_t n)
+ multiallocation_chain allocate_nodes(const size_type n)
 {
 //Preallocate all needed blocks to fulfill the request
- std::size_t cur_nodes = m_freelist.size();
+ size_type cur_nodes = m_freelist.size();
 if(cur_nodes < n){
 priv_alloc_block(((n - cur_nodes) - 1)/m_nodes_per_block + 1);
 }
@@ -102,7 +103,7 @@
 //We just iterate the needed nodes to get the last we'll erase
 typedef typename free_nodes_t::iterator free_iterator;
 free_iterator before_last_new_it = m_freelist.before_begin();
- for(std::size_t j = 0; j != n; ++j){
+ for(size_type j = 0; j != n; ++j){
 ++before_last_new_it;
 }

@@ -120,7 +121,7 @@
 multiallocation_chain chain;
 chain.incorporate_after(chain.before_begin(), &*first_node, &*last_node, n);
 m_allocated += n;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
+ return boost::move(chain);
 }

 void deallocate_nodes(multiallocation_chain chain)
@@ -145,8 +146,8 @@
 nodelist_iterator backup_list_last = backup_list.before_begin();

 //Execute the algorithm and get an iterator to the last value
- std::size_t blocksize = get_rounded_size
- (m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ size_type blocksize = get_rounded_size
+ (m_real_node_size*m_nodes_per_block, (size_type) alignment_of<node_t>::value);

 while(it != itend){
 //Collect all the nodes from the block pointed by it
@@ -185,7 +186,7 @@
 }
 }
 //We should have removed all the nodes from the free list
- assert(m_freelist.empty());
+ BOOST_ASSERT(m_freelist.empty());

 //Now pass all the node to the free list again
 m_freelist.splice_after
@@ -196,7 +197,7 @@
 , backup_list.size());
 }

- std::size_t num_free_nodes()
+ size_type num_free_nodes()
 { return m_freelist.size(); }

 //!Deallocates all used memory. Precondition: all nodes allocated from this pool should
@@ -204,9 +205,9 @@
 void purge_blocks()
 {
 //check for memory leaks
- assert(m_allocated==0);
- std::size_t blocksize = get_rounded_size
- (m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ BOOST_ASSERT(m_allocated==0);
+ size_type blocksize = get_rounded_size
+ (m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
 typename blockslist_t::iterator
 it(m_blocklist.begin()), itend(m_blocklist.end()), aux;

@@ -222,8 +223,8 @@

 void swap(private_node_pool_impl &other)
 {
- assert(m_nodes_per_block == other.m_nodes_per_block);
- assert(m_real_node_size == other.m_real_node_size);
+ BOOST_ASSERT(m_nodes_per_block == other.m_nodes_per_block);
+ BOOST_ASSERT(m_real_node_size == other.m_real_node_size);
 std::swap(mp_segment_mngr_base, other.mp_segment_mngr_base);
 m_blocklist.swap(other.m_blocklist);
 m_freelist.swap(other.m_freelist);
@@ -289,20 +290,20 @@
 //We put the node at the beginning of the free node list
 node_t * to_deallocate = static_cast<node_t*>(pElem);
 m_freelist.push_front(*to_deallocate);
- assert(m_allocated>0);
+ BOOST_ASSERT(m_allocated>0);
 --m_allocated;
 }

 //!Allocates several blocks of nodes. Can throw
- void priv_alloc_block(std::size_t num_blocks = 1)
+ void priv_alloc_block(size_type num_blocks = 1)
 {
 if(!num_blocks)
 return;
- std::size_t blocksize =
- get_rounded_size(m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ size_type blocksize =
+ get_rounded_size(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);

 try{
- for(std::size_t i = 0; i != num_blocks; ++i){
+ for(size_type i = 0; i != num_blocks; ++i){
 //We allocate a new NodeBlock and put it as first
 //element in the free Node list
 char *pNode = reinterpret_cast<char*>
@@ -312,7 +313,7 @@

 //We initialize all Nodes in Node Block to insert
 //them in the free Node list
- for(std::size_t i = 0; i < m_nodes_per_block; ++i, pNode += m_real_node_size){
+ for(size_type i = 0; i < m_nodes_per_block; ++i, pNode += m_real_node_size){
 m_freelist.push_front(*new (pNode) node_t);
 }
 }
@@ -333,13 +334,13 @@

 private:
 //!Returns a reference to the block hook placed in the end of the block
- static node_t & get_block_hook (void *block, std::size_t blocksize)
+ static node_t & get_block_hook (void *block, size_type blocksize)
 {
 return *reinterpret_cast<node_t*>(reinterpret_cast<char*>(block) + blocksize);
 }

 //!Returns the starting address of the block reference to the block hook placed in the end of the block
- void *get_block_from_hook (node_t *hook, std::size_t blocksize)
+ void *get_block_from_hook (node_t *hook, size_type blocksize)
 {
 return (reinterpret_cast<char*>(hook) - blocksize);
 }
@@ -348,12 +349,12 @@
 typedef typename boost::pointer_to_other
 <void_pointer, segment_manager_base_type>::type segment_mngr_base_ptr_t;

- const std::size_t m_nodes_per_block;
- const std::size_t m_real_node_size;
+ const size_type m_nodes_per_block;
+ const size_type m_real_node_size;
 segment_mngr_base_ptr_t mp_segment_mngr_base; //Segment manager
 blockslist_t m_blocklist; //Intrusive container of blocks
 free_nodes_t m_freelist; //Intrusive container of free nods
- std::size_t m_allocated; //Used nodes for debugging
+ size_type m_allocated; //Used nodes for debugging
};

Modified: sandbox/move/boost/container/detail/pair.hpp
==============================================================================
--- sandbox/move/boost/container/detail/pair.hpp (original)
+++ sandbox/move/boost/container/detail/pair.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -25,7 +25,8 @@

#include <utility> //std::pair

-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/type_traits/is_class.hpp>

#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
@@ -36,10 +37,36 @@
namespace containers_detail {

template <class T1, class T2>
+struct pair;
+
+template <class T>
+struct is_pair
+{
+ static const bool value = false;
+};
+
+template <class T1, class T2>
+struct is_pair< pair<T1, T2> >
+{
+ static const bool value = true;
+};
+
+template <class T1, class T2>
+struct is_pair< std::pair<T1, T2> >
+{
+ static const bool value = true;
+};
+
+struct pair_nat;
+
+struct piecewise_construct_t { };
+static const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+
+template <class T1, class T2>
struct pair
{
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(pair)
+ BOOST_COPYABLE_AND_MOVABLE(pair)

 public:
 typedef T1 first_type;
@@ -48,109 +75,173 @@
 T1 first;
 T2 second;

- //std::pair compatibility
- template <class D, class S>
- pair(const std::pair<D, S>& p)
- : first(p.first), second(p.second)
+ //Default constructor
+ pair()
+ : first(), second()
 {}
+/*
+ //pair from two values
+ pair(const T1 &t1, const T2 &t2)
+ : first(t1)
+ , second(t2)
+ {}
+

- //To resolve ambiguity with the variadic constructor of 1 argument
- //and the previous constructor
- pair(std::pair<T1, T2>& x)
+ //pair from two values
+ pair(BOOST_RV_REF(T1) t1, BOOST_RV_REF(T2) t2)
+ : first(::boost::move(t1))
+ , second(::boost::move(t2))
+ {}
+*/
+ template<class U, class V>
+ pair(BOOST_FWD_REF(U) u, BOOST_FWD_REF(V) v)
+ : first(::boost::forward(u))
+ , second(::boost::forward<V>(v))
+ {}
+
+ //pair copy assignment
+ pair(const pair& x)
 : first(x.first), second(x.second)
 {}

 template <class D, class S>
- pair(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+ pair(const pair<D, S> &p)
+ : first(p.first), second(p.second)
 {}

- pair()
- : first(), second()
+ //pair move constructor
+ pair(BOOST_RV_REF(pair) p)
+ : first(::boost::move(p.first)), second(::boost::move(p.second))
 {}

- pair(const pair<T1, T2>& x)
- : first(x.first), second(x.second)
+ template <class D, class S>
+ pair(BOOST_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
+ : first(::boost::move(p.first)), second(::boost::move(p.second))
 {}

- //To resolve ambiguity with the variadic constructor of 1 argument
- //and the copy constructor
- pair(pair<T1, T2>& x)
+ //std::pair copy constructor
+ pair(const std::pair<T1, T2>& x)
 : first(x.first), second(x.second)
 {}

- pair(BOOST_MOVE_MACRO_RV_REF(pair) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+ template <class D, class S>
+ pair(const std::pair<D, S>& p)
+ : first(p.first), second(p.second)
 {}

+ //std::pair move constructor
 template <class D, class S>
- pair(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+ pair(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ : first(::boost::move(p.first)), second(::boost::move(p.second))
 {}

- #ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
+ pair(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
+ : first(::boost::move(p.first)), second(::boost::move(p.second))
+ {}

- template<class U, class ...Args>
- pair(U &&u, Args &&... args)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(u))
- , second(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ //piecewise_construct missing
+/*
+ //Variadic versions
+ template<class U>
+ pair(BOOST_CONTAINERS_PARAM(U, u), typename containers_detail::disable_if
+ < containers_detail::is_pair< typename containers_detail::remove_ref_const::type >, pair_nat>::type* = 0)
+ : first(::boost::forward(u))
+ , second()
 {}

- #else
+ #ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

- template<class U>
- pair( BOOST_CONTAINERS_PARAM(U, u)
- #ifdef BOOST_NO_RVALUE_REFERENCES
- , typename containers_detail::disable_if
- < containers_detail::is_same<U, ::BOOST_CONTAINER_MOVE_NAMESPACE::rv<pair> > >::type* = 0
- #endif
- )
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(const_cast<U&>(u)))
+ template<class U, class V, class ...Args>
+ pair(U &&u, V &&v)
+ : first(::boost::forward(u))
+ , second(::boost::forward<V>(v), ::boost::forward<Args>(args)...)
 {}

+ #else
+
 #define BOOST_PP_LOCAL_MACRO(n) \
 template<class U, BOOST_PP_ENUM_PARAMS(n, class P)> \
 pair(BOOST_CONTAINERS_PARAM(U, u) \
 ,BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(const_cast<U&>(u))) \
+ : first(::boost::forward(u)) \
 , second(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)) \
 {} \
 //!
 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINERS_MAX_CONSTRUCTOR_PARAMETERS)
 #include BOOST_PP_LOCAL_ITERATE()
 #endif
+*/
+ //pair copy assignment
+ pair& operator=(BOOST_COPY_ASSIGN_REF(pair) p)
+ {
+ first = p.first;
+ second = p.second;
+ return *this;
+ }

- pair& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(pair) p)
+ template <class D, class S>
+ pair& operator=(const pair<D, S>&p)
 {
 first = p.first;
 second = p.second;
 return *this;
 }

- pair& operator=(BOOST_MOVE_MACRO_RV_REF(pair) p)
+ //pair move assignment
+ pair& operator=(BOOST_RV_REF(pair) p)
 {
- first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
- second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
+ first = ::boost::move(p.first);
+ second = ::boost::move(p.second);
 return *this;
 }

- pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
+ template <class D, class S>
+ pair& operator=(BOOST_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
 {
- first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
- second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
+ first = ::boost::move(p.first);
+ second = ::boost::move(p.second);
+ return *this;
+ }
+
+ //std::pair copy assignment
+ pair& operator=(const std::pair<T1, T2> &p)
+ {
+ first = p.first;
+ second = p.second;
 return *this;
 }

 template <class D, class S>
- pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ pair& operator=(const std::pair<D, S> &p)
+ {
+ first = ::boost::move(p.first);
+ second = ::boost::move(p.second);
+ return *this;
+ }
+
+ //std::pair move assignment
+ pair& operator=(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
 {
- first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
- second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
+ first = ::boost::move(p.first);
+ second = ::boost::move(p.second);
 return *this;
 }

+ template <class D, class S>
+ pair& operator=(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ {
+ first = ::boost::move(p.first);
+ second = ::boost::move(p.second);
+ return *this;
+ }
+
+ //swap
 void swap(pair& p)
- { std::swap(*this, p); }
+ {
+ using std::swap;
+ swap(this->first, p.first);
+ swap(this->second, p.second);
+ }
};

template <class T1, class T2>
@@ -205,6 +296,23 @@
 static const bool value = false;
};

+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+template <class T1, class T2>
+struct is_class< ::boost::container::containers_detail::pair<T1, T2> >
+ : public ::boost::true_type
+{};
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+
+template<class T1, class T2>
+struct has_move_emulation_enabled< ::boost::container::containers_detail::pair<T1, T2> >
+ : ::boost::true_type
+{};
+
+#endif
+
+
} //namespace boost {

#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

Modified: sandbox/move/boost/container/detail/preprocessor.hpp
==============================================================================
--- sandbox/move/boost/container/detail/preprocessor.hpp (original)
+++ sandbox/move/boost/container/detail/preprocessor.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,11 @@
#endif

#include "config_begin.hpp"
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+#include INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP
+#endif
+
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -57,9 +62,21 @@
#endif

#ifndef BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+
+#define BOOST_CONTAINERS_AUX_PARAM_INIT(z, n, data) \
+ BOOST_PP_CAT(m_p, n) (boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) )) \
+//!
+
+#else
+
#define BOOST_CONTAINERS_AUX_PARAM_INIT(z, n, data) \
- BOOST_PP_CAT(m_p, n) (BOOST_PP_CAT(p, n)) \
+ BOOST_PP_CAT(m_p, n) (static_cast<BOOST_PP_CAT(P, n)>( BOOST_PP_CAT(p, n) )) \
//!
+
+#endif
+
#else
#define BOOST_CONTAINERS_AUX_PARAM_INIT(z, n, data) \
 BOOST_PP_CAT(m_p, n) (const_cast<BOOST_PP_CAT(P, n) &>(BOOST_PP_CAT(p, n))) \
@@ -71,9 +88,22 @@
//!

#ifndef BOOST_NO_RVALUE_REFERENCES
+
+#if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#define BOOST_CONTAINERS_AUX_PARAM_DEFINE(z, n, data) \
+ BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n); \
+//!
+
+#else
+
#define BOOST_CONTAINERS_AUX_PARAM_DEFINE(z, n, data) \
 BOOST_PP_CAT(P, n) && BOOST_PP_CAT(m_p, n); \
//!
+
+#endif //defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+
#else
#define BOOST_CONTAINERS_AUX_PARAM_DEFINE(z, n, data) \
 BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n); \
@@ -81,13 +111,23 @@
#endif

#define BOOST_CONTAINERS_PP_PARAM_FORWARD(z, n, data) \
-BOOST_CONTAINER_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
+boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
//!

+#if !defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
#define BOOST_CONTAINERS_PP_MEMBER_FORWARD(z, n, data) \
-BOOST_CONTAINER_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(m_p, n) ) \
+::boost::container::containers_detail::stored_ref< BOOST_PP_CAT(P, n) >::forward( BOOST_PP_CAT(m_p, n) ) \
//!

+#else
+
+#define BOOST_CONTAINERS_PP_MEMBER_FORWARD(z, n, data) \
+boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(m_p, n) ) \
+//!
+
+#endif //!defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
#define BOOST_CONTAINERS_PP_MEMBER_IT_FORWARD(z, n, data) \
BOOST_PP_CAT(*m_p, n) \
//!

Added: sandbox/move/boost/container/detail/stored_ref.hpp
==============================================================================
--- (empty file)
+++ sandbox/move/boost/container/detail/stored_ref.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -0,0 +1,92 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINERS_DETAIL_STORED_REF_HPP
+#define BOOST_CONTAINERS_DETAIL_STORED_REF_HPP
+
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+
+namespace boost{
+namespace container{
+namespace containers_detail{
+
+template<class T>
+struct stored_ref
+{
+
+ static T && forward(T &t)
+ #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+ { return t; }
+ #else
+ { return boost::move(t); }
+ #endif
+};
+
+template<class T>
+struct stored_ref<const T>
+{
+ static const T && forward(const T &t)
+ #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+ { return t; }
+ #else
+ { return static_cast<const T&&>(t); }
+ #endif
+};
+
+template<class T>
+struct stored_ref<T&&>
+{
+ static T && forward(T &t)
+ #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+ { return t; }
+ #else
+ { return boost::move(t); }
+ #endif
+};
+
+template<class T>
+struct stored_ref<const T&&>
+{
+ static const T && forward(const T &t)
+ #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+ { return t; }
+ #else
+ { return static_cast<const T &&>(t); }
+ #endif
+};
+
+template<class T>
+struct stored_ref<const T&>
+{
+ static const T & forward(const T &t)
+ { return t; }
+};
+
+template<class T>
+struct stored_ref<T&>
+{
+ static T & forward(T &t)
+ { return t; }
+};
+
+} //namespace containers_detail{
+} //namespace container{
+} //namespace boost{
+
+#else
+#error "This header can be included only for compiler with rvalue references"
+#endif //BOOST_NO_RVALUE_REFERENCES
+
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP
+
+#endif //BOOST_CONTAINERS_DETAIL_STORED_REF_HPP

Modified: sandbox/move/boost/container/detail/transform_iterator.hpp
==============================================================================
--- sandbox/move/boost/container/detail/transform_iterator.hpp (original)
+++ sandbox/move/boost/container/detail/transform_iterator.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -47,11 +47,11 @@
 : m_value(px)
 {}

- T* operator->() const { return &m_value; }
+ T* operator->() const { return const_cast<T*>(&m_value); }
 // This function is needed for MWCW and BCC, which won't call operator->
 // again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; }
- mutable T &m_value;
+ T &m_value;
};

template <class Iterator, class UnaryFunction>

Modified: sandbox/move/boost/container/detail/tree.hpp
==============================================================================
--- sandbox/move/boost/container/detail/tree.hpp (original)
+++ sandbox/move/boost/container/detail/tree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -15,7 +15,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP

-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/detail/no_exceptions_support.hpp>
@@ -26,6 +26,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif
@@ -47,7 +48,7 @@
 typedef KeyOfValue key_of_value;
 typedef Key key_type;

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

@@ -57,9 +58,25 @@
 key_compare &key_comp()
 { return static_cast<key_compare &>(*this); }

- template<class A, class B>
- bool operator()(const A &a, const B &b) const
- { return key_compare::operator()(KeyOfValue()(a), KeyOfValue()(b)); }
+ template<class T>
+ struct is_key
+ {
+ static const bool value = is_same<const T, const key_type>::value;
+ };
+
+ template<class T>
+ typename enable_if_c<is_key<T>::value, const key_type &>::type
+ key_forward(const T &key) const
+ { return key; }
+
+ template<class T>
+ typename enable_if_c<!is_key<T>::value, const key_type &>::type
+ key_forward(const T &key) const
+ { return KeyOfValue()(key); }
+
+ template<class KeyType, class KeyType2>
+ bool operator()(const KeyType &key1, const KeyType2 &key2) const
+ { return key_compare::operator()(this->key_forward(key1), this->key_forward(key2)); }
};

template<class VoidPointer>
@@ -122,7 +139,7 @@

 template<class ...Args>
 rbtree_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
 {}
 #endif//#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -164,8 +181,8 @@

 public:
 template<class Convertible>
- static void construct(node_type *ptr, BOOST_MOVE_MACRO_FWD_REF(Convertible) convertible)
- { new(ptr) node_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Convertible>(convertible)); }
+ static void construct(node_type *ptr, BOOST_FWD_REF(Convertible) convertible)
+ { new(ptr) node_type(boost::forward<Convertible>(convertible)); }
};

}//namespace containers_detail {
@@ -267,7 +284,7 @@
 AllocHolder &m_holder;
 Icont &m_icont;
 };
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(rbtree)
+ BOOST_COPYABLE_AND_MOVABLE(rbtree)

 public:

@@ -296,17 +313,29 @@
 struct key_node_compare
 : private KeyValueCompare
 {
- key_node_compare(KeyValueCompare comp)
+ key_node_compare(const KeyValueCompare &comp)
 : KeyValueCompare(comp)
 {}
-
- template<class KeyType>
- bool operator()(const Node &n, const KeyType &k) const
- { return KeyValueCompare::operator()(n.get_data(), k); }
-
- template<class KeyType>
- bool operator()(const KeyType &k, const Node &n) const
- { return KeyValueCompare::operator()(k, n.get_data()); }
+
+ template<class T>
+ struct is_node
+ {
+ static const bool value = is_same<T, Node>::value;
+ };
+
+ template<class T>
+ typename enable_if_c<is_node<T>::value, const value_type &>::type
+ key_forward(const T &node) const
+ { return node.get_data(); }
+
+ template<class T>
+ typename enable_if_c<!is_node<T>::value, const T &>::type
+ key_forward(const T &key) const
+ { return key; }
+
+ template<class KeyType, class KeyType2>
+ bool operator()(const KeyType &key1, const KeyType2 &key2) const
+ { return KeyValueCompare::operator()(this->key_forward(key1), this->key_forward(key2)); }
 };

 typedef key_node_compare<value_compare> KeyNodeCompare;
@@ -437,14 +466,14 @@
 (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
 }

- rbtree(BOOST_MOVE_MACRO_RV_REF(rbtree) x)
+ rbtree(BOOST_RV_REF(rbtree) x)
 : AllocHolder(x, x.key_comp())
 { this->swap(x); }

 ~rbtree()
 {} //AllocHolder clears the tree

- rbtree& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(rbtree) x)
+ rbtree& operator=(BOOST_COPY_ASSIGN_REF(rbtree) x)
 {
 if (this != &x) {
 //Transfer all the nodes to a temporary tree
@@ -469,7 +498,7 @@
 return *this;
 }

- rbtree& operator=(BOOST_MOVE_MACRO_RV_REF(rbtree) mx)
+ rbtree& operator=(BOOST_RV_REF(rbtree) mx)
 { this->clear(); this->swap(mx); return *this; }

 public:
@@ -589,9 +618,9 @@

 template<class MovableConvertible>
 iterator insert_unique_commit
- (BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv, insert_commit_data &data)
+ (BOOST_FWD_REF(MovableConvertible) mv, insert_commit_data &data)
 {
- NodePtr tmp = AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv));
+ NodePtr tmp = AllocHolder::create_node(boost::forward<MovableConvertible>(mv));
 iiterator it(this->icont().insert_unique_commit(*tmp, data));
 return iterator(it);
 }
@@ -608,7 +637,7 @@
 }

 template<class MovableConvertible>
- std::pair<iterator,bool> insert_unique(BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ std::pair<iterator,bool> insert_unique(BOOST_FWD_REF(MovableConvertible) mv)
 {
 insert_commit_data data;
 std::pair<iterator,bool> ret =
@@ -616,7 +645,7 @@
 if(!ret.second)
 return ret;
 return std::pair<iterator,bool>
- (this->insert_unique_commit(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv), data), true);
+ (this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data), true);
 }

 private:
@@ -652,23 +681,23 @@

 template <class... Args>
 iterator emplace_unique(Args&&... args)
- { return this->emplace_unique_impl(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return this->emplace_unique_impl(AllocHolder::create_node(boost::forward<Args>(args)...)); }

 template <class... Args>
 iterator emplace_hint_unique(const_iterator hint, Args&&... args)
- { return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(boost::forward<Args>(args)...)); }

 template <class... Args>
 iterator emplace_equal(Args&&... args)
 {
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
 return iterator(this->icont().insert_equal(this->icont().end(), *p));
 }

 template <class... Args>
 iterator emplace_hint_equal(const_iterator hint, Args&&... args)
 {
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
 return iterator(this->icont().insert_equal(hint.get(), *p));
 }

@@ -737,14 +766,14 @@
 }

 template<class MovableConvertible>
- iterator insert_unique(const_iterator hint, BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_unique(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
 {
 insert_commit_data data;
 std::pair<iterator,bool> ret =
 this->insert_unique_check(hint, KeyOfValue()(mv), data);
 if(!ret.second)
 return ret.first;
- return this->insert_unique_commit(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv), data);
+ return this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data);
 }

 template <class InputIterator>
@@ -770,9 +799,9 @@
 }

 template<class MovableConvertible>
- iterator insert_equal(BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_equal(BOOST_FWD_REF(MovableConvertible) mv)
 {
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv)));
+ NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
 return iterator(this->icont().insert_equal(this->icont().end(), *p));
 }

@@ -783,9 +812,9 @@
 }

 template<class MovableConvertible>
- iterator insert_equal(const_iterator hint, BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_equal(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
 {
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv)));
+ NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
 return iterator(this->icont().insert_equal(hint.get(), *p));
 }

Modified: sandbox/move/boost/container/detail/type_traits.hpp
==============================================================================
--- sandbox/move/boost/container/detail/type_traits.hpp (original)
+++ sandbox/move/boost/container/detail/type_traits.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -21,6 +21,8 @@

#include "config_begin.hpp"

+#include <boost/move/move.hpp>
+
namespace boost {
namespace container {
namespace containers_detail {
@@ -81,6 +83,24 @@
typedef T type;
};

+#ifndef BOOST_NO_RVALUE_REFERENCES
+
+template<class T>
+struct remove_reference<T&&>
+{
+ typedef T type;
+};
+
+#else
+
+template<class T>
+struct remove_reference< ::boost::rv<T> >
+{
+ typedef T type;
+};
+
+#endif
+
template<class T>
struct is_reference
{
@@ -156,11 +176,28 @@
static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
};

+template<class T>
+struct remove_const
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_const< const T>
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_ref_const
+{
+ typedef typename remove_const< typename remove_reference<T>::type >::type type;
+};
+
} // namespace containers_detail
} //namespace container {
} //namespace boost {

-#endif //#ifndef BOOST_CONTAINERS_CONTAINER_DETAIL_TYPE_TRAITS_HPP
-
#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

+#endif //#ifndef BOOST_CONTAINERS_CONTAINER_DETAIL_TYPE_TRAITS_HPP

Modified: sandbox/move/boost/container/detail/utilities.hpp
==============================================================================
--- sandbox/move/boost/container/detail/utilities.hpp (original)
+++ sandbox/move/boost/container/detail/utilities.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -17,7 +17,8 @@
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_member_pointer.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/type_traits/is_class.hpp>
+#include <boost/move/move.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <algorithm>
@@ -26,6 +27,14 @@
namespace container {
namespace containers_detail {

+template<class T>
+const T &max_value(const T &a, const T &b)
+{ return a > b ? a : b; }
+
+template<class T>
+const T &min_value(const T &a, const T &b)
+{ return a 
SizeType
 get_next_capacity(const SizeType max_size
@@ -46,14 +55,6 @@
 return max_size;
}

-template<class T>
-const T &max_value(const T &a, const T &b)
-{ return a > b ? a : b; }
-
-template<class T>
-const T &min_value(const T &a, const T &b)
-{ return a 
struct smart_ptr_type
{
@@ -87,7 +88,8 @@
}

//Rounds "orig_size" by excess to round_to bytes
-inline std::size_t get_rounded_size(std::size_t orig_size, std::size_t round_to)
+template<class SizeType>
+inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
{
 return ((orig_size-1)/round_to+1)*round_to;
}
@@ -131,10 +133,10 @@
template<class T>
struct move_const_ref_type
 : if_c
- < ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value ||
- ::boost::is_member_pointer<T>::value || ::boost::is_enum<T>::value
+// < ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value || ::boost::is_enum<T>::value
+ < !::boost::is_class<T>::value
 ,const T &
- ,BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(T)
+ ,BOOST_CATCH_CONST_RLVALUE(T)
>
{};

Modified: sandbox/move/boost/container/detail/version_type.hpp
==============================================================================
--- sandbox/move/boost/container/detail/version_type.hpp (original)
+++ sandbox/move/boost/container/detail/version_type.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -21,7 +21,6 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP

-
namespace boost{
namespace container {
namespace containers_detail {
@@ -88,4 +87,6 @@
} //namespace container {
} //namespace boost{

+#include "config_end.hpp"
+
#endif //#define BOOST_CONTAINERS_DETAIL_VERSION_TYPE_HPP

Modified: sandbox/move/boost/container/detail/workaround.hpp
==============================================================================
--- sandbox/move/boost/container/detail/workaround.hpp (original)
+++ sandbox/move/boost/container/detail/workaround.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2011. 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)
//
@@ -14,7 +14,7 @@
#include "config_begin.hpp"

#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)\
- && !defined(BOOST_MOVE_MACRO_DISABLE_VARIADIC_TMPL)
+ && !defined(BOOST_INTERPROCESS_DISABLE_VARIADIC_TMPL)
#define BOOST_CONTAINERS_PERFECT_FORWARDING

#endif

Modified: sandbox/move/boost/container/flat_map.hpp
==============================================================================
--- sandbox/move/boost/container/flat_map.hpp (original)
+++ sandbox/move/boost/container/flat_map.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -26,7 +26,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -76,7 +76,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_map)
+ BOOST_COPYABLE_AND_MOVABLE(flat_map)
 //This is the tree that we should store if pair was movable
 typedef containers_detail::flat_tree<Key,
 std::pair<Key, T>,
@@ -192,14 +192,14 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_map(BOOST_MOVE_MACRO_RV_REF(flat_map) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_map(BOOST_RV_REF(flat_map) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
 {}

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- flat_map<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_map) x)
+ flat_map<Key,T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

 //! Effects: Move constructs a flat_map.
@@ -208,8 +208,8 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_map<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_map) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_map<Key,T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_map) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -385,13 +385,13 @@
 //! Returns: A reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
- T &operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk)
+ T &operator[](BOOST_RV_REF(key_type) mk)
 {
 key_type &k = mk;
 iterator i = lower_bound(k);
 // i->first is greater than or equivalent to k.
 if (i == end() || key_comp()(k, (*i).first))
- i = insert(i, value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T())));
+ i = insert(i, value_type(boost::move(k), boost::move(T())));
 return (*i).second;
 }

@@ -454,9 +454,9 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
 { return force<std::pair<iterator,bool> >(
- m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(force<impl_value_type>(x)))); }
+ m_flat_tree.insert_unique(boost::move(force<impl_value_type>(x)))); }

 //! Effects: Inserts a new value_type move constructed from the pair if and
 //! only if there is no element in the container with key equivalent to the key of x.
@@ -469,10 +469,10 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ std::pair<iterator,bool> insert(BOOST_RV_REF(impl_value_type) x)
 {
 return force<std::pair<iterator,bool> >
- (m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ (m_flat_tree.insert_unique(boost::move(x)));
 }

 //! Effects: Inserts a copy of x in the container if and only if there is
@@ -499,9 +499,9 @@
 //! 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.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
 { return force_copy<iterator>(
- m_flat_tree.insert_unique(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(force<impl_value_type>(x)))); }
+ m_flat_tree.insert_unique(force<impl_const_iterator>(position), boost::move(force<impl_value_type>(x)))); }

 //! Effects: Inserts an element move constructed from x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -512,10 +512,10 @@
 //! 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.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
 {
 return force_copy<iterator>(
- m_flat_tree.insert_unique(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ m_flat_tree.insert_unique(force<impl_const_iterator>(position), boost::move(x)));
 }

 //! Requires: i, j are not iterators into *this.
@@ -547,7 +547,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container if and only if there is
@@ -563,7 +563,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), boost::forward<Args>(args)...)); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -818,7 +818,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_multimap)
+ BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
 typedef containers_detail::flat_tree<Key,
 std::pair<Key, T>,
 containers_detail::select1st< std::pair<Key, T> >,
@@ -932,21 +932,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_multimap(BOOST_MOVE_MACRO_RV_REF(flat_multimap) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_multimap(BOOST_RV_REF(flat_multimap) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
 { }

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multimap) x)
+ flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

 //! Effects: this->swap(x.get()).
 //!
 //! Complexity: Constant.
- flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multimap) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_multimap) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -1093,8 +1093,8 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return force_copy<iterator>(m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }

 //! Effects: Inserts a new value move-constructed from x and returns
 //! the iterator pointing to the newly inserted element.
@@ -1103,8 +1103,8 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
- { return force_copy<iterator>(m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ iterator insert(BOOST_RV_REF(impl_value_type) x)
+ { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -1131,11 +1131,11 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
 {
 return force_copy<iterator>
 (m_flat_tree.insert_equal(force<impl_const_iterator>(position)
- , BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ , boost::move(x)));
 }

 //! Effects: Inserts a value move constructed from x in the container.
@@ -1149,10 +1149,10 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
 {
 return force_copy<iterator>(
- m_flat_tree.insert_equal(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ m_flat_tree.insert_equal(force<impl_const_iterator>(position), boost::move(x)));
 }

 //! Requires: i, j are not iterators into *this.
@@ -1179,7 +1179,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container.
@@ -1197,7 +1197,7 @@
 iterator emplace_hint(const_iterator hint, Args&&... args)
 {
 return force_copy<iterator>(m_flat_tree.emplace_hint_equal
- (force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ (force<impl_const_iterator>(hint), boost::forward<Args>(args)...));
 }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

Modified: sandbox/move/boost/container/flat_set.hpp
==============================================================================
--- sandbox/move/boost/container/flat_set.hpp (original)
+++ sandbox/move/boost/container/flat_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -24,7 +24,7 @@
#include <memory>
#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -65,7 +65,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_set)
+ BOOST_COPYABLE_AND_MOVABLE(flat_set)
 typedef containers_detail::flat_tree<T, T, containers_detail::identity<T>, Pred, Alloc> tree_t;
 tree_t m_flat_tree; // flat tree representing flat_set
 typedef typename containers_detail::
@@ -139,21 +139,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_set(BOOST_MOVE_MACRO_RV_REF(flat_set) mx)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree))
+ flat_set(BOOST_RV_REF(flat_set) mx)
+ : m_flat_tree(boost::move(mx.m_flat_tree))
 {}

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- flat_set<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_set) x)
+ flat_set<T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- flat_set<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_set) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_set<T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_set) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -336,7 +336,7 @@
 { return this->insert(const_cast<const T &>(x)); }

 template<class U>
- std::pair<iterator, bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ std::pair<iterator, bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(u); }
 #endif

@@ -351,8 +351,8 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_unique(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container if and only if there is
 //! no element in the container with key equivalent to the key of x.
@@ -373,7 +373,7 @@
 { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -386,8 +386,8 @@
 //! 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.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_unique(position, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -418,7 +418,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container if and only if there is
@@ -434,7 +434,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -685,7 +685,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_multiset)
+ BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
 typedef containers_detail::flat_tree<T, T, containers_detail::identity<T>, Pred, Alloc> tree_t;
 tree_t m_flat_tree; // flat tree representing flat_multiset
 typedef typename containers_detail::
@@ -740,15 +740,15 @@
 flat_multiset(const flat_multiset<T,Pred,Alloc>& x)
 : m_flat_tree(x.m_flat_tree) {}

- flat_multiset(BOOST_MOVE_MACRO_RV_REF(flat_multiset) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_multiset(BOOST_RV_REF(flat_multiset) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
 {}

- flat_multiset<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multiset) x)
+ flat_multiset<T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

- flat_multiset<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multiset) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_multiset<T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_multiset) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -927,7 +927,7 @@
 { return this->insert(const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(u); }
 #endif

@@ -938,8 +938,8 @@
 //! to the elements with bigger keys than x.
 //!
 //! Note: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_equal(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -959,7 +959,7 @@
 { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -973,8 +973,8 @@
 //! 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.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_equal(position, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -1000,7 +1000,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container.
@@ -1015,7 +1015,7 @@
 //! Note: If an element it's inserted it might invalidate elements.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

Modified: sandbox/move/boost/container/list.hpp
==============================================================================
--- sandbox/move/boost/container/list.hpp (original)
+++ sandbox/move/boost/container/list.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -18,7 +18,8 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
@@ -72,7 +73,7 @@

 template<class ...Args>
 list_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
 {}

 #else //#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -131,8 +132,6 @@
 <A, typename containers_detail::intrusive_list_type<A>::type>
{
 /// @cond
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 typedef typename
 containers_detail::intrusive_list_type<A>::type Icont;
 typedef list <T, A> ThisType;
@@ -198,7 +197,7 @@

 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(list)
+ BOOST_COPYABLE_AND_MOVABLE(list)
 typedef difference_type list_difference_type;
 typedef pointer list_pointer;
 typedef const_pointer list_const_pointer;
@@ -357,8 +356,8 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- list(BOOST_MOVE_MACRO_RV_REF(list) x)
- : AllocHolder(BOOST_CONTAINER_MOVE_NAMESPACE::move(static_cast<AllocHolder&>(x)))
+ list(BOOST_RV_REF(list) x)
+ : AllocHolder(boost::move(static_cast<AllocHolder&>(x)))
 {}

 //! Effects: Constructs a list that will use a copy of allocator a
@@ -530,56 +529,46 @@
 size_type max_size() const
 { return AllocHolder::max_size(); }

- //! Effects: Inserts a copy of t in the beginning of the list.
+
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! Effects: Inserts a copy of x at the beginning of the list.
 //!
 //! Throws: If memory allocation throws or
 //! T's copy constructor throws.
 //!
 //! Complexity: Amortized constant time.
- void push_front(insert_const_ref_type x)
- { this->insert(this->cbegin(), x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_front(T &x) { push_front(const_cast<const T &>(x)); }
-
- template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { this->insert(this->cbegin(), u); }
- #endif
+ void push_front(const T &x);

 //! Effects: Constructs a new element in the beginning of the list
- //! and moves the resources of t to this new element.
+ //! and moves the resources of mx to this new element.
 //!
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_front(BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->insert(this->cbegin(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ void push_front(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_front, T, void, priv_push_front)
+ #endif

- //! Effects: Removes the last element from the list.
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! Effects: Inserts a copy of x at the end of the list.
 //!
- //! Throws: Nothing.
+ //! Throws: If memory allocation throws or
+ //! T's copy constructor throws.
 //!
 //! Complexity: Amortized constant time.
- void push_back (insert_const_ref_type x)
- { this->insert(this->cend(), x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_back(T &x) { push_back(const_cast<const T &>(x)); }
-
- template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { this->insert(this->cend(), u); }
-
- #endif
+ void push_back(const T &x);

- //! Effects: Removes the first element from the list.
+ //! Effects: Constructs a new element in the end of the list
+ //! and moves the resources of mx to this new element.
 //!
- //! Throws: Nothing.
+ //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_back (BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
+ #endif

 //! Effects: Removes the first element from the list.
 //!
@@ -716,7 +705,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- ThisType& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(ThisType) x)
+ ThisType& operator=(BOOST_COPY_ASSIGN_REF(ThisType) x)
 {
 if (this != &x) {
 this->assign(x.begin(), x.end());
@@ -732,7 +721,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- ThisType& operator=(BOOST_MOVE_MACRO_RV_REF(ThisType) mx)
+ ThisType& operator=(BOOST_RV_REF(ThisType) mx)
 {
 this->clear();
 this->swap(mx);
@@ -760,41 +749,32 @@
 template <class InpIt>
 void insert(const_iterator p, InpIt first, InpIt last)
 {
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_insert_dispatch(p, first, last, Result());
 }

- //! Requires: p must be a valid iterator of *this.
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! Requires: position must be a valid iterator of *this.
 //!
- //! Effects: Insert a copy of x before p.
+ //! Effects: Insert a copy of x before position.
 //!
 //! Throws: If memory allocation throws or x's copy constructor throws.
 //!
 //! Complexity: Amortized constant time.
- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x) { return this->insert(position, const_cast<const T &>(x)); }
+ iterator insert(const_iterator position, const T &x);

- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
-
- //! Requires: p must be a valid iterator of *this.
+ //! Requires: position must be a valid iterator of *this.
 //!
- //! Effects: Insert a new element before p with mx's resources.
+ //! Effects: Insert a new element before position with mx's resources.
 //!
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(T) x)
- {
- NodePtr tmp = AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
- return iterator(this->icont().insert(p.get(), *tmp));
- }
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif

 #if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

@@ -808,7 +788,7 @@
 template <class... Args>
 void emplace_back(Args&&... args)
 {
- this->emplace(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace(this->cend(), boost::forward<Args>(args)...);
 }

 //! Effects: Inserts an object of type T constructed with
@@ -821,7 +801,7 @@
 template <class... Args>
 void emplace_front(Args&&... args)
 {
- this->emplace(this->cbegin(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace(this->cbegin(), boost::forward<Args>(args)...);
 }

 //! Effects: Inserts an object of type T constructed with
@@ -835,7 +815,7 @@
 iterator emplace(const_iterator p, Args&&... args)
 {
 typename AllocHolder::Deallocator d(AllocHolder::create_node_and_deallocator());
- new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(boost::forward<Args>(args)...);
 NodePtr node = d.get();
 d.release();
 return iterator(this->icont().insert(p.get(), *node));
@@ -923,7 +903,7 @@
 template <class InpIt>
 void assign(InpIt first, InpIt last)
 {
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_assign_dispatch(first, last, Result());
 }
@@ -1166,6 +1146,24 @@
 return iterator(this->icont().insert(p.get(), *tmp));
 }

+ iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x)
+ {
+ NodePtr tmp = AllocHolder::create_node(boost::move(x));
+ return iterator(this->icont().insert(p.get(), *tmp));
+ }
+
+ void priv_push_back (const T &x)
+ { this->insert(this->cend(), x); }
+
+ void priv_push_back (BOOST_RV_REF(T) x)
+ { this->insert(this->cend(), boost::move(x)); }
+
+ void priv_push_front (const T &x)
+ { this->insert(this->cbegin(), x); }
+
+ void priv_push_front (BOOST_RV_REF(T) x)
+ { this->insert(this->cbegin(), boost::move(x)); }
+
 //Iterator range version
 template<class InpIterator>
 void priv_create_and_insert_nodes

Modified: sandbox/move/boost/container/map.hpp
==============================================================================
--- sandbox/move/boost/container/map.hpp (original)
+++ sandbox/move/boost/container/map.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -61,7 +61,9 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#include <boost/move/move.hpp>
+#include <boost/static_assert.hpp>

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -99,13 +101,14 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(map)
+ BOOST_COPYABLE_AND_MOVABLE(map)
 typedef containers_detail::rbtree<Key,
 std::pair<const Key, T>,
 containers_detail::select1st< std::pair<const Key, T> >,
 Pred,
 Alloc> tree_t;
 tree_t m_tree; // red-black tree representing map
+
 /// @endcond

 public:
@@ -154,7 +157,10 @@
 explicit map(const Pred& comp = Pred(),
 const allocator_type& a = allocator_type())
 : m_tree(comp, a)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Constructs an empty map using the specified comparison object and
 //! allocator, and inserts elements from the range [first ,last ).
@@ -165,7 +171,10 @@
 map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
 const allocator_type& a = allocator_type())
 : m_tree(first, last, comp, a, true)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Constructs an empty map using the specified comparison object and
 //! allocator, and inserts elements from the ordered unique range [first ,last). This function
@@ -179,35 +188,44 @@
 map( ordered_unique_range_t, InputIterator first, InputIterator last
 , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
 : m_tree(ordered_range, first, last, comp, a)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Copy constructs a map.
 //!
 //! Complexity: Linear in x.size().
 map(const map<Key,T,Pred,Alloc>& x)
 : m_tree(x.m_tree)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Move constructs a map. Constructs *this using x's resources.
 //!
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- map(BOOST_MOVE_MACRO_RV_REF(map) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
- {}
+ map(BOOST_RV_REF(map) x)
+ : m_tree(boost::move(x.m_tree))
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- map& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(map) x)
+ map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
 { m_tree = x.m_tree; return *this; }

 //! Effects: this->swap(x.get()).
 //!
 //! Complexity: Constant.
- map& operator=(BOOST_MOVE_MACRO_RV_REF(map) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ map& operator=(BOOST_RV_REF(map) x)
+ { m_tree = boost::move(x.m_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -341,27 +359,27 @@
 // i->first is greater than or equivalent to k.
 if (i == end() || key_comp()(k, (*i).first)){
 containers_detail::value_init<T> v;
- value_type val(k, BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t));
- i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ value_type val(k, boost::move(v.m_t));
+ i = insert(i, boost::move(val));
 }
 return (*i).second;
 }

 //! 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)
+ //! value_type(boost::move(x), T()) into the map (the key is move-constructed)
 //!
 //! Returns: A reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
- T& operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk)
+ T& operator[](BOOST_RV_REF(key_type) mk)
 {
 key_type &k = mk;
 //we can optimize this
 iterator i = lower_bound(k);
 // i->first is greater than or equivalent to k.
 if (i == end() || key_comp()(k, (*i).first)){
- value_type val(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T()));
- i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ value_type val(boost::move(k), boost::move(T()));
+ i = insert(i, boost::move(val));
 }
 return (*i).second;
 }
@@ -429,8 +447,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }

 //! Effects: Inserts a new value_type move constructed from the pair if and
 //! only if there is no element in the container with key equivalent to the key of x.
@@ -440,8 +458,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }

 //! Effects: Move constructs a new value from x if and only if there is
 //! no element in the container with key equivalent to the key of x.
@@ -451,8 +469,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container if and only if there is
 //! no element in the container with key equivalent to the key of x.
@@ -475,8 +493,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }

 //! Effects: Move constructs a new value from x if and only if there is
 //! no element in the container with key equivalent to the key of x.
@@ -487,8 +505,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -505,8 +523,8 @@
 //! Returns: An iterator pointing to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -532,7 +550,7 @@
 //! is inserted right before p.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_unique(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container if and only if there is
@@ -546,7 +564,7 @@
 //! is inserted right before p.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -752,7 +770,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(multimap)
+ BOOST_COPYABLE_AND_MOVABLE(multimap)
 typedef containers_detail::rbtree<Key,
 std::pair<const Key, T>,
 containers_detail::select1st< std::pair<const Key, T> >,
@@ -807,7 +825,10 @@
 explicit multimap(const Pred& comp = Pred(),
 const allocator_type& a = allocator_type())
 : m_tree(comp, a)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Constructs an empty multimap using the specified comparison object
 //! and allocator, and inserts elements from the range [first ,last ).
@@ -819,7 +840,10 @@
 const Pred& comp = Pred(),
 const allocator_type& a = allocator_type())
 : m_tree(first, last, comp, a, false)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Constructs an empty multimap using the specified comparison object and
 //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -840,28 +864,34 @@
 //! Complexity: Linear in x.size().
 multimap(const multimap<Key,T,Pred,Alloc>& x)
 : m_tree(x.m_tree)
- {}
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Move constructs a multimap. Constructs *this using x's resources.
 //!
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- multimap(BOOST_MOVE_MACRO_RV_REF(multimap) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
- {}
+ multimap(BOOST_RV_REF(multimap) x)
+ : m_tree(boost::move(x.m_tree))
+ {
+ //Allocator type must be std::pair<CONST Key, T>
+ BOOST_STATIC_ASSERT((containers_detail::is_same<std::pair<const Key, T>, typename Alloc::value_type>::value));
+ }

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- multimap& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multimap) x)
+ multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x)
 { m_tree = x.m_tree; return *this; }

 //! Effects: this->swap(x.get()).
 //!
 //! Complexity: Constant.
- multimap& operator=(BOOST_MOVE_MACRO_RV_REF(multimap) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ multimap& operator=(BOOST_RV_REF(multimap) x)
+ { m_tree = boost::move(x.m_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -1009,15 +1039,15 @@
 //! the iterator pointing to the newly inserted element.
 //!
 //! Complexity: Logarithmic.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }

 //! Effects: Inserts a new value move-constructed from x and returns
 //! the iterator pointing to the newly inserted element.
 //!
 //! Complexity: Logarithmic.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -1049,8 +1079,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_equal(position, boost::move(x)); }

 //! Effects: Inserts a new value move constructed from x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -1060,8 +1090,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_equal(position, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -1085,7 +1115,7 @@
 //! is inserted right before p.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container.
@@ -1098,7 +1128,7 @@
 //! is inserted right before p.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

Modified: sandbox/move/boost/container/set.hpp
==============================================================================
--- sandbox/move/boost/container/set.hpp (original)
+++ sandbox/move/boost/container/set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -23,10 +23,10 @@
#include <functional>
#include <memory>

-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif
@@ -62,7 +62,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(set)
+ BOOST_COPYABLE_AND_MOVABLE(set)
 typedef containers_detail::rbtree<T, T,
 containers_detail::identity<T>, Pred, Alloc> tree_t;
 tree_t m_tree; // red-black tree representing set
@@ -136,21 +136,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- set(BOOST_MOVE_MACRO_RV_REF(set) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ set(BOOST_RV_REF(set) x)
+ : m_tree(boost::move(x.m_tree))
 {}

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- set& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(set) x)
+ set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
 { m_tree = x.m_tree; return *this; }

 //! Effects: this->swap(x.get()).
 //!
 //! Complexity: Constant.
- set& operator=(BOOST_MOVE_MACRO_RV_REF(set) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ set& operator=(BOOST_RV_REF(set) x)
+ { m_tree = boost::move(x.m_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -330,7 +330,7 @@
 { return this->insert(const_cast<const T &>(x)); }

 template<class U>
- std::pair<iterator,bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ std::pair<iterator,bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(u); }
 #endif

@@ -342,8 +342,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container if and only if there is
 //! no element in the container with key equivalent to the key of x.
@@ -362,7 +362,7 @@
 { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -372,8 +372,8 @@
 //! Returns: An iterator pointing to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(p, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(p, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -399,7 +399,7 @@
 //! Complexity: Logarithmic.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_unique(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... if and only if there is
@@ -412,7 +412,7 @@
 //! Complexity: Logarithmic.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -620,7 +620,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(multiset)
+ BOOST_COPYABLE_AND_MOVABLE(multiset)
 typedef containers_detail::rbtree<T, T,
 containers_detail::identity<T>, Pred, Alloc> tree_t;
 tree_t m_tree; // red-black tree representing multiset
@@ -695,21 +695,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- multiset(BOOST_MOVE_MACRO_RV_REF(multiset) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ multiset(BOOST_RV_REF(multiset) x)
+ : m_tree(boost::move(x.m_tree))
 {}

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- multiset& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multiset) x)
+ multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
 { m_tree = x.m_tree; return *this; }

 //! Effects: this->swap(x.get()).
 //!
 //! Complexity: Constant.
- multiset& operator=(BOOST_MOVE_MACRO_RV_REF(multiset) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ multiset& operator=(BOOST_RV_REF(multiset) x)
+ { m_tree = boost::move(x.m_tree); return *this; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -885,7 +885,7 @@
 { return this->insert(const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(u); }
 #endif

@@ -896,8 +896,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -915,7 +915,7 @@
 { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -927,8 +927,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_equal(p, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_equal(p, boost::move(x)); }

 //! Requires: i, j are not iterators into *this.
 //!
@@ -948,7 +948,7 @@
 //! Complexity: Logarithmic.
 template <class... Args>
 iterator emplace(Args&&... args)
- { return m_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)...
@@ -960,7 +960,7 @@
 //! is inserted right before p.
 template <class... Args>
 iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

Modified: sandbox/move/boost/container/slist.hpp
==============================================================================
--- sandbox/move/boost/container/slist.hpp (original)
+++ sandbox/move/boost/container/slist.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -19,7 +19,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
@@ -73,7 +73,7 @@

 template<class ...Args>
 slist_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
 {}

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -222,7 +222,7 @@

 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(slist)
+ BOOST_COPYABLE_AND_MOVABLE(slist)
 typedef difference_type list_difference_type;
 typedef pointer list_pointer;
 typedef const_pointer list_const_pointer;
@@ -372,8 +372,8 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- slist(BOOST_MOVE_MACRO_RV_REF(slist) x)
- : AllocHolder(BOOST_CONTAINER_MOVE_NAMESPACE::move((AllocHolder&)x))
+ slist(BOOST_RV_REF(slist) x)
+ : AllocHolder(boost::move((AllocHolder&)x))
 {}

 //! Effects: Makes *this contain the same elements as x.
@@ -384,7 +384,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- slist& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(slist) x)
+ slist& operator= (BOOST_COPY_ASSIGN_REF(slist) x)
 {
 if (&x != this){
 this->assign(x.begin(), x.end());
@@ -400,7 +400,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- slist& operator= (BOOST_MOVE_MACRO_RV_REF(slist) mx)
+ slist& operator= (BOOST_RV_REF(slist) mx)
 {
 if (&mx != this){
 this->clear();
@@ -451,7 +451,7 @@
 template <class InpIt>
 void assign(InpIt first, InpIt last)
 {
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_assign_dispatch(first, last, Result());
 }
@@ -603,7 +603,7 @@
 void push_front(T &x) { push_front(const_cast<const T &>(x)); }

 template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_push_front(u); }
 #endif

@@ -613,8 +613,8 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_front(BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->icont().push_front(*this->create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ void push_front(BOOST_RV_REF(T) x)
+ { this->icont().push_front(*this->create_node(boost::move(x))); }

 //! Effects: Removes the first element from the list.
 //!
@@ -665,7 +665,7 @@
 { return this->insert_after(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert_after(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert_after(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return this->priv_insert_after(position, u); }
 #endif

@@ -682,8 +682,8 @@
 //!
 //! Note: Does not affect the validity of iterators and references of
 //! previous values.
- iterator insert_after(const_iterator prev_pos, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)))); }
+ iterator insert_after(const_iterator prev_pos, BOOST_RV_REF(value_type) x)
+ { return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(boost::move(x)))); }

 //! Requires: prev_pos must be a valid iterator of *this.
 //!
@@ -713,7 +713,7 @@
 template <class InIter>
 void insert_after(const_iterator prev_pos, InIter first, InIter last)
 {
- const bool aux_boolean = containers_detail::is_convertible<InIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIter, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_insert_after_range_dispatch(prev_pos, first, last, Result());
 }
@@ -733,7 +733,7 @@
 { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

@@ -744,8 +744,8 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Linear to the elements before p.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return this->insert_after(previous(p), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return this->insert_after(previous(p), boost::move(x)); }

 //! Requires: p must be a valid iterator of *this.
 //!
@@ -781,7 +781,7 @@
 //! Complexity: Amortized constant time.
 template <class... Args>
 void emplace_front(Args&&... args)
- { this->emplace_after(this->cbefore_begin(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { this->emplace_after(this->cbefore_begin(), boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... before p
@@ -792,7 +792,7 @@
 //! Complexity: Linear to the elements before p
 template <class... Args>
 iterator emplace(const_iterator p, Args&&... args)
- { return this->emplace_after(this->previous(p), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return this->emplace_after(this->previous(p), boost::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... after prev
@@ -805,7 +805,7 @@
 iterator emplace_after(const_iterator prev, Args&&... args)
 {
 typename AllocHolder::Deallocator d(AllocHolder::create_node_and_deallocator());
- new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(boost::forward<Args>(args)...);
 NodePtr node = d.get();
 d.release();
 return iterator(this->icont().insert_after(prev.get(), *node));
@@ -1338,7 +1338,7 @@

 template<class Integer>
 void priv_insert_dispatch(const_iterator prev, Integer n, Integer x, containers_detail::true_)
- { this->priv_create_and_insert_nodes(prev, (std::size_t)n, x); }
+ { this->priv_create_and_insert_nodes(prev, (size_type)n, x); }

 void priv_fill_assign(size_type n, const T& val)
 {
@@ -1380,7 +1380,7 @@

 template <class Int>
 void priv_insert_after_range_dispatch(const_iterator prev_pos, Int n, Int x, containers_detail::true_)
- { this->priv_create_and_insert_nodes(prev_pos, (std::size_t)n, x); }
+ { this->priv_create_and_insert_nodes(prev_pos, (size_type)n, x); }

 template <class InIter>
 void priv_insert_after_range_dispatch(const_iterator prev_pos, InIter first, InIter last, containers_detail::false_)

Modified: sandbox/move/boost/container/stable_vector.hpp
==============================================================================
--- sandbox/move/boost/container/stable_vector.hpp (original)
+++ sandbox/move/boost/container/stable_vector.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztanaga 2008-2009. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2008-2011. 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)
//
@@ -140,7 +140,7 @@

 template<class ...Args>
 node_type(Args &&...args)
- : value(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : value(boost::forward<Args>(args)...)
 {}

 #else //BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -177,10 +177,14 @@

 typedef typename boost::pointer_to_other
 <Pointer, void>::type void_ptr;
+ typedef typename boost::pointer_to_other
+ <Pointer, const void>::type const_void_ptr;
 typedef node_type<void_ptr, T> node_type_t;
 typedef typename boost::pointer_to_other
 <void_ptr, node_type_t>::type node_type_ptr_t;
 typedef typename boost::pointer_to_other
+ <void_ptr, const node_type_t>::type const_node_type_ptr_t;
+ typedef typename boost::pointer_to_other
 <void_ptr, void_ptr>::type void_ptr_ptr;

 friend class iterator<T, const T, typename boost::pointer_to_other<Pointer, T>::type>;
@@ -205,13 +209,19 @@
 {}

 private:
- static node_type_ptr_t node_ptr_cast(void_ptr p)
+ static node_type_ptr_t node_ptr_cast(const void_ptr &p)
 {
 using boost::get_pointer;
 return node_type_ptr_t(static_cast<node_type_t*>(stable_vector_detail::get_pointer(p)));
 }

- static void_ptr_ptr void_ptr_ptr_cast(void_ptr p)
+ static const_node_type_ptr_t node_ptr_cast(const const_void_ptr &p)
+ {
+ using boost::get_pointer;
+ return const_node_type_ptr_t(static_cast<const node_type_t*>(stable_vector_detail::get_pointer(p)));
+ }
+
+ static void_ptr_ptr void_ptr_ptr_cast(const void_ptr &p)
 {
 using boost::get_pointer;
 return void_ptr_ptr(static_cast<void_ptr*>(stable_vector_detail::get_pointer(p)));
@@ -225,9 +235,9 @@
 { pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)+1)); }
 void decrement()
 { pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)-1)); }
- void advance(std::ptrdiff_t n)
+ void advance(difference_type n)
 { pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)+n)); }
- std::ptrdiff_t distance_to(const iterator& x)const
+ difference_type distance_to(const iterator& x)const
 { return void_ptr_ptr_cast(x.pn->up) - void_ptr_ptr_cast(pn->up); }

 public:
@@ -261,9 +271,9 @@
 return *this;
 }

- iterator operator+(difference_type off) const
+ friend iterator operator+(const iterator &left, difference_type off)
 {
- iterator tmp(*this);
+ iterator tmp(left);
 tmp += off;
 return tmp;
 }
@@ -278,38 +288,36 @@
 iterator& operator-=(difference_type off)
 { *this += -off; return *this; }

- iterator operator-(difference_type off) const
+ friend iterator operator-(const iterator &left, difference_type off)
 {
- iterator tmp(*this);
+ iterator tmp(left);
 tmp -= off;
 return tmp;
 }

- difference_type operator-(const iterator& right) const
+ friend difference_type operator-(const iterator& left, const iterator& right)
 {
- void_ptr_ptr p1 = void_ptr_ptr_cast(this->pn->up);
- void_ptr_ptr p2 = void_ptr_ptr_cast(right.pn->up);
- return p1 - p2;
+ return void_ptr_ptr_cast(left.pn->up) - void_ptr_ptr_cast(right.pn->up);
 }

 //Comparison operators
- bool operator== (const iterator& r) const
- { return pn == r.pn; }
+ friend bool operator== (const iterator& l, const iterator& r)
+ { return l.pn == r.pn; }

- bool operator!= (const iterator& r) const
- { return pn != r.pn; }
+ friend bool operator!= (const iterator& l, const iterator& r)
+ { return l.pn != r.pn; }

- bool operator< (const iterator& r) const
- { return void_ptr_ptr_cast(pn->up) < void_ptr_ptr_cast(r.pn->up); }
+ friend bool operator< (const iterator& l, const iterator& r)
+ { return void_ptr_ptr_cast(l.pn->up) < void_ptr_ptr_cast(r.pn->up); }

- bool operator<= (const iterator& r) const
- { return void_ptr_ptr_cast(pn->up) <= void_ptr_ptr_cast(r.pn->up); }
+ friend bool operator<= (const iterator& l, const iterator& r)
+ { return void_ptr_ptr_cast(l.pn->up) <= void_ptr_ptr_cast(r.pn->up); }

- bool operator> (const iterator& r) const
- { return void_ptr_ptr_cast(pn->up) > void_ptr_ptr_cast(r.pn->up); }
+ friend bool operator> (const iterator& l, const iterator& r)
+ { return void_ptr_ptr_cast(l.pn->up) > void_ptr_ptr_cast(r.pn->up); }

- bool operator>= (const iterator& r) const
- { return void_ptr_ptr_cast(pn->up) >= void_ptr_ptr_cast(r.pn->up); }
+ friend bool operator>= (const iterator& l, const iterator& r)
+ { return void_ptr_ptr_cast(l.pn->up) >= void_ptr_ptr_cast(r.pn->up); }

 node_type_ptr_t pn;
};
@@ -346,7 +354,11 @@

/// @endcond

-//!Help taken from ( Introducing stable_vector)
+//!Originally developed by Joaquin M. Lopez Munoz, stable_vector is std::vector
+//!drop-in replacement implemented as a node container, offering iterator and reference
+//!stability.
+//!
+//!More details taken the author's blog: ( 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.
@@ -379,8 +391,12 @@
 move_const_ref_type<T>::type insert_const_ref_type;
 typedef typename Allocator::template
 rebind<void>::other::pointer void_ptr;
+ typedef typename boost::pointer_to_other
+ <void_ptr, const void>::type const_void_ptr;
 typedef typename Allocator::template
 rebind<void_ptr>::other::pointer void_ptr_ptr;
+ typedef typename boost::pointer_to_other
+ <void_ptr, const void_ptr>::type const_void_ptr_ptr;
 typedef stable_vector_detail::node_type
 <void_ptr, T> node_type_t;
 typedef typename Allocator::template
@@ -454,8 +470,14 @@

 ///@cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(stable_vector)
+ BOOST_COPYABLE_AND_MOVABLE(stable_vector)
 static const size_type ExtraPointers = 3;
+ //This container stores metadata at the end of the void_ptr vector with additional 3 pointers:
+ // back() is impl.back() - ExtraPointers;
+ // end node index is impl.end()[-3]
+ // Node cache first is impl.end()[-2];
+ // Node cache last is *impl.back();
+
 typedef typename stable_vector_detail::
 select_multiallocation_chain
 < node_allocator_type
@@ -464,13 +486,24 @@
 ///@endcond
 public:

- // construct/copy/destroy:
+ //! Effects: Constructs a stable_vector taking the allocator as parameter.
+ //!
+ //! Throws: If allocator_type's copy constructor throws.
+ //!
+ //! Complexity: Constant.
 explicit stable_vector(const Allocator& al=Allocator())
 : internal_data(al),impl(al)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
 }

+ //! Effects: Constructs a stable_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.
 explicit stable_vector(size_type n)
 : internal_data(Allocator()),impl(Allocator())
 {
@@ -480,6 +513,13 @@
 cod.release();
 }

+ //! Effects: Constructs a stable_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.
 stable_vector(size_type n, const T& t, const Allocator& al=Allocator())
 : internal_data(al),impl(al)
 {
@@ -489,6 +529,13 @@
 cod.release();
 }

+ //! Effects: Constructs a stable_vector that will use a copy of allocator a
+ //! and inserts a copy of the range [first, last) in the stable_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).
 template <class InputIterator>
 stable_vector(InputIterator first,InputIterator last,const Allocator& al=Allocator())
 : internal_data(al),impl(al)
@@ -499,6 +546,11 @@
 cod.release();
 }

+ //! Effects: Copy constructs a stable_vector.
+ //!
+ //! Postcondition: x == *this.
+ //!
+ //! Complexity: Linear to the elements x contains.
 stable_vector(const stable_vector& x)
 : internal_data(x.get_al()),impl(x.get_al())
 {
@@ -508,17 +560,36 @@
 cod.release();
 }

- stable_vector(BOOST_MOVE_MACRO_RV_REF(stable_vector) x)
+ //! Effects: Move constructor. Moves mx's resources to *this.
+ //!
+ //! Throws: If allocator_type's copy constructor throws.
+ //!
+ //! Complexity: Constant.
+ stable_vector(BOOST_RV_REF(stable_vector) x)
 : internal_data(x.get_al()),impl(x.get_al())
 { this->swap(x); }

+ //! Effects: Destroys the stable_vector. All stored values are destroyed
+ //! and used memory is deallocated.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the number of elements.
 ~stable_vector()
 {
 this->clear();
 clear_pool();
 }

- stable_vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(stable_vector) x)
+ //! 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.
+ stable_vector& operator=(BOOST_COPY_ASSIGN_REF(stable_vector) x)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
 if (this != &x) {
@@ -527,7 +598,15 @@
 return *this;
 }

- stable_vector& operator=(BOOST_MOVE_MACRO_RV_REF(stable_vector) x)
+ //! 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.
+ stable_vector& operator=(BOOST_RV_REF(stable_vector) x)
 {
 if (&x != this){
 this->swap(x);
@@ -536,48 +615,152 @@
 return *this;
 }

+ //! 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.
 template<typename InputIterator>
 void assign(InputIterator first,InputIterator last)
 {
 assign_dispatch(first, last, boost::is_integral<InputIterator>());
 }

+
+ //! Effects: Assigns the n copies of val to *this.
+ //!
+ //! Throws: If memory allocation throws or T's copy constructor throws.
+ //!
+ //! Complexity: Linear to n.
 void assign(size_type n,const T& t)
 {
 typedef constant_iterator<value_type, difference_type> cvalue_iterator;
 return assign_dispatch(cvalue_iterator(t, n), cvalue_iterator(), boost::mpl::false_());
 }

+ //! Effects: Returns a copy of the internal allocator.
+ //!
+ //! Throws: If allocator's copy constructor throws.
+ //!
+ //! Complexity: Constant.
 allocator_type get_allocator()const {return get_al();}

- // iterators:

+ //! Effects: Returns an iterator to the first element contained in the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 iterator begin()
 { return (impl.empty()) ? end(): iterator(node_ptr_cast(impl.front())) ; }

+ //! Effects: Returns a const_iterator to the first element contained in the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator begin()const
 { return (impl.empty()) ? cend() : const_iterator(node_ptr_cast(impl.front())) ; }

+ //! Effects: Returns an iterator to the end of the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 iterator end() {return iterator(get_end_node());}
+
+ //! Effects: Returns a const_iterator to the end of the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_iterator end()const {return const_iterator(get_end_node());}

+ //! Effects: Returns a reverse_iterator pointing to the beginning
+ //! of the reversed stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reverse_iterator rbegin() {return reverse_iterator(this->end());}
+
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator rbegin()const {return const_reverse_iterator(this->end());}
+
+ //! Effects: Returns a reverse_iterator pointing to the end
+ //! of the reversed stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reverse_iterator rend() {return reverse_iterator(this->begin());}
+
+ //! Effects: Returns a const_reverse_iterator pointing to the end
+ //! of the reversed stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reverse_iterator rend()const {return const_reverse_iterator(this->begin());}

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

- // capacity:
+ //! Effects: Returns the number of the elements contained in the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 size_type size() const
 { return impl.empty() ? 0 : (impl.size() - ExtraPointers); }

+ //! Effects: Returns the largest possible size of the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 size_type max_size() const
 { return impl.max_size() - ExtraPointers; }

+ //! Effects: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 size_type capacity() const
 {
 if(!impl.capacity()){
@@ -590,9 +773,20 @@
 }
 }

+ //! Effects: Returns true if the stable_vector contains no elements.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 bool empty() const
 { return impl.empty() || impl.size() == ExtraPointers; }

+ //! 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.
 void resize(size_type n, const T& t)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
@@ -602,6 +796,12 @@
 this->erase(this->cbegin() + n, this->cend());
 }

+ //! 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.
 void resize(size_type n)
 {
 typedef default_construct_iterator<value_type, difference_type> default_iterator;
@@ -612,6 +812,12 @@
 this->erase(this->cbegin() + n, this->cend());
 }

+ //! 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.
 void reserve(size_type n)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
@@ -636,39 +842,106 @@
 }
 }

- // element access:
-
+ //! Requires: size() < n.
+ //!
+ //! Effects: Returns a reference to the nth element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reference operator[](size_type n){return value(impl[n]);}
+
+ //! Requires: size() < n.
+ //!
+ //! Effects: Returns a const reference to the nth element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference operator[](size_type n)const{return value(impl[n]);}

- const_reference at(size_type n)const
+ //! 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.
+ reference at(size_type n)
 {
 if(n>=size())
 throw std::out_of_range("invalid subscript at stable_vector::at");
 return operator[](n);
 }

- reference at(size_type n)
+ //! Requires: size() < n.
+ //!
+ //! Effects: Returns a const reference to the nth element
+ //! from the beginning of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
+ const_reference at(size_type n)const
 {
 if(n>=size())
 throw std::out_of_range("invalid subscript at stable_vector::at");
 return operator[](n);
 }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a reference to the first
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reference front()
 { return value(impl.front()); }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a const reference to the first
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference front()const
 { return value(impl.front()); }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a reference to the last
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 reference back()
 { return value(*(&impl.back() - ExtraPointers)); }

+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a const reference to the last
+ //! element of the container.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 const_reference back()const
 { return value(*(&impl.back() - ExtraPointers)); }

- // modifiers:
-
+ //! Effects: Inserts a copy of x at the end of the stable_vector.
+ //!
+ //! Throws: If memory allocation throws or
+ //! T's copy constructor throws.
+ //!
+ //! Complexity: Amortized constant time.
 void push_back(insert_const_ref_type x)
 { return priv_push_back(x); }

@@ -676,16 +949,35 @@
 void push_back(T &x) { push_back(const_cast<const T &>(x)); }

 template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return priv_push_back(u); }
 #endif

- void push_back(BOOST_MOVE_MACRO_RV_REF(T) t)
- { this->insert(end(), BOOST_CONTAINER_MOVE_NAMESPACE::move(t)); }
+ //! Effects: Constructs a new element in the end of the stable_vector
+ //! and moves the resources of mx to this new element.
+ //!
+ //! Throws: If memory allocation throws.
+ //!
+ //! Complexity: Amortized constant time.
+ void push_back(BOOST_RV_REF(T) t)
+ { this->insert(end(), boost::move(t)); }

+ //! Effects: Removes the last element from the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant time.
 void pop_back()
 { this->erase(this->end()-1); }

+ //! 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.
 iterator insert(const_iterator position, insert_const_ref_type x)
 { return this->priv_insert(position, x); }

@@ -693,14 +985,22 @@
 iterator insert(const_iterator position, T &x) { return this->insert(position, const_cast<const T &>(x)); }

 template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x)
+ //! 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.
+ //!
+ //! Complexity: If position is end(), amortized constant time
+ //! Linear time otherwise.
+ iterator insert(const_iterator position, BOOST_RV_REF(T) x)
 {
 typedef repeat_iterator<T, difference_type> repeat_it;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<repeat_it> repeat_move_it;
+ typedef boost::move_iterator<repeat_it> repeat_move_it;
 //Just call more general insert(pos, size, value) and return iterator
 size_type pos_n = position - cbegin();
 this->insert(position
@@ -709,12 +1009,27 @@
 return iterator(this->begin() + pos_n);
 }

+ //! 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.
 void insert(const_iterator position, size_type n, const T& t)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
 this->insert_not_iter(position, n, t);
 }

+ //! 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).
 template <class InputIterator>
 void insert(const_iterator position,InputIterator first, InputIterator last)
 {
@@ -726,7 +1041,7 @@
 #if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

 //! Effects: Inserts an object of type T constructed with
- //! std::forward<Args>(args)... in the end of the vector.
+ //! std::forward<Args>(args)... in the end of the stable_vector.
 //!
 //! Throws: If memory allocation throws or the in-place constructor throws.
 //!
@@ -735,8 +1050,8 @@
 void emplace_back(Args &&...args)
 {
 typedef emplace_functor<node_type_t, Args...> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
- EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
+ EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
 this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
 }

@@ -755,8 +1070,8 @@
 //Just call more general insert(pos, size, value) and return iterator
 size_type pos_n = position - cbegin();
 typedef emplace_functor<node_type_t, Args...> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
- EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
+ EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
 this->insert(position, EmplaceIterator(ef), EmplaceIterator());
 return iterator(this->begin() + pos_n);
 }
@@ -766,7 +1081,7 @@
 void emplace_back()
 {
 typedef emplace_functor<node_type_t> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
 EmplaceFunctor ef;
 this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
 }
@@ -774,7 +1089,7 @@
 iterator emplace(const_iterator position)
 {
 typedef emplace_functor<node_type_t> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
 EmplaceFunctor ef;
 size_type pos_n = position - this->cbegin();
 this->insert(position, EmplaceIterator(ef), EmplaceIterator());
@@ -787,7 +1102,7 @@
 { \
 typedef BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg) \
 <node_type_t, BOOST_PP_ENUM_PARAMS(n, P)> EmplaceFunctor; \
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator; \
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator; \
 EmplaceFunctor ef(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator()); \
 } \
@@ -797,7 +1112,7 @@
 { \
 typedef BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg) \
 <node_type_t, BOOST_PP_ENUM_PARAMS(n, P)> EmplaceFunctor; \
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator; \
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator; \
 EmplaceFunctor ef(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 size_type pos_n = pos - this->cbegin(); \
 this->insert(pos, EmplaceIterator(ef), EmplaceIterator()); \
@@ -809,31 +1124,84 @@

 #endif //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

+ //! 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 last element.
 iterator erase(const_iterator position)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
- difference_type d=position-this->cbegin();
- impl_iterator it=impl.begin()+d;
+ difference_type d = position - this->cbegin();
+ impl_iterator it = impl.begin() + d;
 this->delete_node(*it);
- impl.erase(it);
- this->align_nodes(impl.begin()+d,get_last_align());
+ it = impl.erase(it);
+ this->align_nodes(it, get_last_align());
 return this->begin()+d;
 }

+ //! Effects: Erases the elements pointed by [first, last).
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the distance between first and last
+ //! plus linear to the elements between pos and the last element.
 iterator erase(const_iterator first, const_iterator last)
 { return priv_erase(first, last, alloc_version()); }

+ //! Effects: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type()
+ //! allocators are also swapped.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Constant.
 void swap(stable_vector & x)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
 this->swap_impl(*this,x);
 }

+ //! Effects: Erases all the elements of the stable_vector.
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Complexity: Linear to the number of elements in the stable_vector.
 void clear()
 { this->erase(this->cbegin(),this->cend()); }

+ //! Effects: Tries to deallocate the excess of memory created
+ //! with previous allocations. The size of the stable_vector is unchanged
+ //!
+ //! Throws: If memory allocation throws.
+ //!
+ //! Complexity: Linear to size().
+ void shrink_to_fit()
+ {
+ if(this->capacity()){
+ //First empty allocated node pool
+ this->clear_pool();
+ //If empty completely destroy the index, let's recover default-constructed state
+ if(this->empty()){
+ impl_type().swap(this->impl);
+ this->internal_data.set_end_pointer_to_default_constructed();
+ }
+ //Otherwise, try to shrink-to-fit the index and readjust pointers if necessary
+ else{
+ const size_type size = this->size();
+ const void* old_ptr = &impl[0];
+ this->impl.shrink_to_fit();
+ bool realloced = &impl[0] != old_ptr;
+ //Fix the pointers for the newly allocated buffer
+ if(realloced){
+ this->align_nodes(impl.begin(), impl.begin()+size+1);
+ }
+ }
+ }
+ }
+
 /// @cond
- private:

 iterator priv_insert(const_iterator position, const value_type &t)
 {
@@ -847,17 +1215,17 @@
 void clear_pool(allocator_v1)
 {
 if(!impl.empty() && impl.back()){
- void_ptr &p1 = *(impl.end()-2);
- void_ptr &p2 = impl.back();
+ void_ptr &pool_first_ref = impl.end()[-2];
+ void_ptr &pool_last_ref = impl.back();

 multiallocation_chain holder;
- holder.incorporate_after(holder.before_begin(), p1, p2, this->internal_data.pool_size);
+ holder.incorporate_after(holder.before_begin(), pool_first_ref, pool_last_ref, this->internal_data.pool_size);
 while(!holder.empty()){
 node_type_ptr_t n = holder.front();
 holder.pop_front();
 this->deallocate_one(n);
 }
- p1 = p2 = 0;
+ pool_first_ref = pool_last_ref = 0;
 this->internal_data.pool_size = 0;
 }
 }
@@ -866,12 +1234,12 @@
 {

 if(!impl.empty() && impl.back()){
- void_ptr &p1 = *(impl.end()-2);
- void_ptr &p2 = impl.back();
+ void_ptr &pool_first_ref = impl.end()[-2];
+ void_ptr &pool_last_ref = impl.back();
 multiallocation_chain holder;
- holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
- get_al().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(holder));
- p1 = p2 = 0;
+ holder.incorporate_after(holder.before_begin(), pool_first_ref, pool_last_ref, internal_data.pool_size);
+ get_al().deallocate_individual(boost::move(holder));
+ pool_first_ref = pool_last_ref = 0;
 this->internal_data.pool_size = 0;
 }
 }
@@ -896,30 +1264,30 @@

 void add_to_pool(size_type n, allocator_v2)
 {
- void_ptr &p1 = *(impl.end()-2);
- void_ptr &p2 = impl.back();
+ void_ptr &pool_first_ref = impl.end()[-2];
+ void_ptr &pool_last_ref = impl.back();
 multiallocation_chain holder;
- holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
- BOOST_STATIC_ASSERT((::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<multiallocation_chain>::value == true));
+ holder.incorporate_after(holder.before_begin(), pool_first_ref, pool_last_ref, internal_data.pool_size);
+ //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<multiallocation_chain>::value == true));
 multiallocation_chain m (get_al().allocate_individual(n));
 holder.splice_after(holder.before_begin(), m, m.before_begin(), m.last(), n);
 this->internal_data.pool_size += n;
 std::pair<void_ptr, void_ptr> data(holder.extract_data());
- p1 = data.first;
- p2 = data.second;
+ pool_first_ref = data.first;
+ pool_last_ref = data.second;
 }

 void put_in_pool(node_type_ptr_t p)
 {
- void_ptr &p1 = *(impl.end()-2);
- void_ptr &p2 = impl.back();
+ void_ptr &pool_first_ref = impl.end()[-2];
+ void_ptr &pool_last_ref = impl.back();
 multiallocation_chain holder;
- holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
+ holder.incorporate_after(holder.before_begin(), pool_first_ref, pool_last_ref, internal_data.pool_size);
 holder.push_front(p);
 ++this->internal_data.pool_size;
 std::pair<void_ptr, void_ptr> ret(holder.extract_data());
- p1 = ret.first;
- p2 = ret.second;
+ pool_first_ref = ret.first;
+ pool_last_ref = ret.second;
 }

 node_type_ptr_t get_from_pool()
@@ -928,20 +1296,20 @@
 return node_type_ptr_t(0);
 }
 else{
- void_ptr &p1 = *(impl.end()-2);
- void_ptr &p2 = impl.back();
+ void_ptr &pool_first_ref = impl.end()[-2];
+ void_ptr &pool_last_ref = impl.back();
 multiallocation_chain holder;
- holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
+ holder.incorporate_after(holder.before_begin(), pool_first_ref, pool_last_ref, internal_data.pool_size);
 node_type_ptr_t ret = holder.front();
 holder.pop_front();
 --this->internal_data.pool_size;
 if(!internal_data.pool_size){
- p1 = p2 = 0;
+ pool_first_ref = pool_last_ref = void_ptr(0);
 }
 else{
 std::pair<void_ptr, void_ptr> data(holder.extract_data());
- p1 = data.first;
- p2 = data.second;
+ pool_first_ref = data.first;
+ pool_last_ref = data.second;
 }
 return ret;
 }
@@ -992,8 +1360,8 @@
 impl_iterator it1(impl.begin() + d1), it2(impl.begin() + d2);
 for(impl_iterator it = it1; it != it2; ++it)
 this->delete_node(*it);
- impl.erase(it1, it2);
- this->align_nodes(impl.begin() + d1, get_last_align());
+ impl_iterator e = impl.erase(it1, it2);
+ this->align_nodes(e, get_last_align());
 }
 return iterator(this->begin() + d1);
 }
@@ -1018,19 +1386,19 @@
 return priv_erase(first, last, allocator_v1());
 }

- static node_type_ptr_t node_ptr_cast(void_ptr p)
+ static node_type_ptr_t node_ptr_cast(const void_ptr &p)
 {
 using boost::get_pointer;
 return node_type_ptr_t(static_cast<node_type_t*>(stable_vector_detail::get_pointer(p)));
 }

- static node_type_base_ptr_t node_base_ptr_cast(void_ptr p)
+ static node_type_base_ptr_t node_base_ptr_cast(const void_ptr &p)
 {
 using boost::get_pointer;
 return node_type_base_ptr_t(static_cast<node_type_base_t*>(stable_vector_detail::get_pointer(p)));
 }

- static value_type& value(void_ptr p)
+ static value_type& value(const void_ptr &p)
 {
 return node_ptr_cast(p)->value;
 }
@@ -1065,7 +1433,7 @@
 }

 template<class Iter>
- void_ptr new_node(void_ptr up, Iter it)
+ void_ptr new_node(const void_ptr &up, Iter it)
 {
 node_type_ptr_t p = this->allocate_one();
 try{
@@ -1079,14 +1447,14 @@
 return p;
 }

- void delete_node(void_ptr p)
+ void delete_node(const void_ptr &p)
 {
 node_type_ptr_t n(node_ptr_cast(p));
 n->~node_type_t();
 this->put_in_pool(n);
 }

- static void align_nodes(impl_iterator first,impl_iterator last)
+ static void align_nodes(impl_iterator first, impl_iterator last)
 {
 while(first!=last){
 node_ptr_cast(*first)->up = void_ptr(&*first);
@@ -1136,14 +1504,14 @@
 size_type i=0;
 try{
 while(first!=last){
- *(it + i) = this->new_node(void_ptr((void*)(&*(it + i))), first);
+ it[i] = this->new_node(void_ptr_ptr(&it[i]), first);
 ++first;
 ++i;
 }
 }
 catch(...){
- impl.erase(it + i, it + n);
- this->align_nodes(it + i, get_last_align());
+ impl_iterator e = impl.erase(it + i, it + n);
+ this->align_nodes(e, get_last_align());
 throw;
 }
 }
@@ -1161,17 +1529,17 @@
 mem.pop_front();
 //This can throw
 boost::container::construct_in_place(&*p, first);
- p->set_pointer(void_ptr((void*)(&*(it + i))));
+ p->set_pointer(void_ptr_ptr(&it[i]));
 ++first;
- *(it + i) = p;
+ it[i] = p;
 ++i;
 }
 }
 catch(...){
 get_al().deallocate_one(p);
- get_al().deallocate_many(BOOST_CONTAINER_MOVE_NAMESPACE::move(mem));
- impl.erase(it+i, it+n);
- this->align_nodes(it+i,get_last_align());
+ get_al().deallocate_many(boost::move(mem));
+ impl_iterator e = impl.erase(it+i, it+n);
+ this->align_nodes(e, get_last_align());
 throw;
 }
 }
@@ -1190,16 +1558,16 @@
 }
 //This can throw
 boost::container::construct_in_place(&*p, first);
- p->set_pointer(void_ptr(&*(it+i)));
+ p->set_pointer(void_ptr_ptr(&it[i]));
 ++first;
- *(it+i)=p;
+ it[i]=p;
 ++i;
 }
 }
 catch(...){
 put_in_pool(p);
- impl.erase(it+i,it+n);
- this->align_nodes(it+i,get_last_align());
+ impl_iterator e = impl.erase(it+i, it+n);
+ this->align_nodes(e, get_last_align());
 throw;
 }
 }
@@ -1228,9 +1596,10 @@
 if(get_end_node() != *(impl.end() - ExtraPointers)){
 return false;
 }
- for(const_impl_iterator it=impl.begin(),it_end=get_last_align();it!=it_end;++it){
- if(node_ptr_cast(*it)->up != &*it)
- return false;
+ for(const_impl_iterator it = impl.begin(), it_end = get_last_align(); it != it_end; ++it){
+ if(const_void_ptr(node_ptr_cast(*it)->up) !=
+ const_void_ptr(const_void_ptr_ptr(&*it)))
+ return false;
 }
 size_type n = capacity()-size();
 const void_ptr &pool_head = impl.back();
@@ -1238,7 +1607,7 @@
 node_type_ptr_t p = node_ptr_cast(pool_head);
 while(p){
 ++num_pool;
- p = p->up;
+ p = node_ptr_cast(p->up);
 }
 return n >= num_pool;
 }
@@ -1259,8 +1628,14 @@
 ebo_holder(const allocator_type &a)
 : node_allocator_type(a), pool_size(0), end_node()
 {
+ this->set_end_pointer_to_default_constructed();
+ }
+
+ void set_end_pointer_to_default_constructed()
+ {
 end_node.set_pointer(void_ptr(&end_node.up));
 }
+
 size_type pool_size;
 node_type_base_t end_node;
 } internal_data;

Modified: sandbox/move/boost/container/string.hpp
==============================================================================
--- sandbox/move/boost/container/string.hpp (original)
+++ sandbox/move/boost/container/string.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -22,7 +22,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/static_assert.hpp>

#include <functional>
@@ -42,6 +42,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/aligned_storage.hpp>

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -67,7 +68,7 @@
class basic_string_base
{
 basic_string_base();
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)

 public:
 typedef A allocator_type;
@@ -81,14 +82,14 @@
 : members_(a)
 { init(); }

- basic_string_base(const allocator_type& a, std::size_t n)
+ basic_string_base(const allocator_type& a, size_type n)
 : members_(a)
 {
 this->init();
 this->allocate_initial_block(n);
 }

- basic_string_base(BOOST_MOVE_MACRO_RV_REF(basic_string_base) b)
+ basic_string_base(BOOST_RV_REF(basic_string_base) b)
 : members_(b.members_)
 {
 init();
@@ -134,14 +135,6 @@
 }
 };

- //This basic type should have the same alignment as long_t
-//iG typedef typename type_with_alignment<containers_detail::alignment_of<long_t>::value>::type
-// long_alignment_type;
- typedef void *long_alignment_type;
- BOOST_STATIC_ASSERT((containers_detail::alignment_of<long_alignment_type>::value %
- containers_detail::alignment_of<long_t>::value) == 0);
-
-
 //This type is the first part of the structure controlling a short string
 //The "data" member stores
 struct short_header
@@ -152,11 +145,9 @@

 //This type has the same alignment and size as long_t but it's POD
 //so, unlike long_t, it can be placed in a union
- struct long_raw_t
- {
- long_alignment_type a;
- unsigned char b[sizeof(long_t) - sizeof(long_alignment_type)];
- };
+
+ typedef typename boost::aligned_storage< sizeof(long_t),
+ containers_detail::alignment_of<long_t>::value>::type long_raw_t;

 protected:
 static const size_type MinInternalBufferChars = 8;
@@ -264,7 +255,7 @@
 (void)limit_size;
 (void)reuse;
 if(!(command & allocate_new))
- return std::pair<pointer, bool>(pointer(0), 0);
+ return std::pair<pointer, bool>(pointer(0), false);
 received_size = preferred_size;
 return std::make_pair(this->alloc().allocate(received_size), false);
 }
@@ -284,7 +275,7 @@
 size_type next_capacity(size_type additional_objects) const
 { return get_next_capacity(this->alloc().max_size(), this->priv_storage(), additional_objects); }

- void deallocate(pointer p, std::size_t n)
+ void deallocate(pointer p, size_type n)
 {
 if (p && (n > InternalBufferChars))
 this->alloc().deallocate(p, n);
@@ -302,7 +293,7 @@
 void destroy(pointer p)
 { containers_detail::get_pointer(p)->~value_type(); }

- void allocate_initial_block(std::size_t n)
+ void allocate_initial_block(size_type n)
 {
 if (n <= this->max_size()) {
 if(n > InternalBufferChars){
@@ -321,7 +312,7 @@
 void deallocate_block()
 { this->deallocate(this->priv_addr(), this->priv_storage()); }

- std::size_t max_size() const
+ size_type max_size() const
 { return this->alloc().max_size() - 1; }

 // Helper functions for exception handling.
@@ -429,7 +420,7 @@
{
 /// @cond
 private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(basic_string)
+ BOOST_COPYABLE_AND_MOVABLE(basic_string)
 typedef containers_detail::basic_string_base<A> base_t;
 static const typename base_t::size_type InternalBufferChars = base_t::InternalBufferChars;

@@ -507,13 +498,14 @@
 public: // Constructor, destructor, assignment.
 /// @cond
 struct reserve_t {};
- /// @endcond

- basic_string(reserve_t, std::size_t n,
+ basic_string(reserve_t, size_type n,
 const allocator_type& a = allocator_type())
 : base_t(a, n + 1)
 { this->priv_terminate_string(); }

+ /// @endcond
+
 //! Effects: Constructs a basic_string taking the allocator as parameter.
 //!
 //! Throws: If allocator_type's copy constructor throws.
@@ -535,8 +527,8 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- basic_string(BOOST_MOVE_MACRO_RV_REF(basic_string) s)
- : base_t(BOOST_CONTAINER_MOVE_NAMESPACE::move((base_t&)s))
+ basic_string(BOOST_RV_REF(basic_string) s)
+ : base_t(boost::move((base_t&)s))
 {}

 //! Effects: Constructs a basic_string taking the allocator as parameter,
@@ -584,7 +576,7 @@
 : base_t(a)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIterator, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIterator, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_initialize_dispatch(f, l, Result());
 }
@@ -602,7 +594,7 @@
 //! Postcondition: x == *this.
 //!
 //! Complexity: Linear to the elements x contains.
- basic_string& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(basic_string) s)
+ basic_string& operator=(BOOST_COPY_ASSIGN_REF(basic_string) s)
 {
 if (&s != this)
 this->assign(s.begin(), s.end());
@@ -614,7 +606,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- basic_string& operator=(BOOST_MOVE_MACRO_RV_REF(basic_string) ms)
+ basic_string& operator=(BOOST_RV_REF(basic_string) ms)
 {
 basic_string &s = ms;
 if (&s != this){
@@ -931,7 +923,7 @@
 { return this->operator=(s); }

 //! Effects: Moves the resources from ms *this.
- basic_string& assign(BOOST_MOVE_MACRO_RV_REF(basic_string) ms)
+ basic_string& assign(BOOST_RV_REF(basic_string) ms)
 { return this->operator=(ms);}

 //! Effects: Assigns the range [pos, pos + n) from s to *this.
@@ -960,7 +952,7 @@
 basic_string& assign(InputIter first, InputIter last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 return this->priv_assign_dispatch(first, last, Result());
 }
@@ -1050,7 +1042,7 @@
 }

 //! Effects: Inserts the character c n-times before position.
- void insert(iterator position, std::size_t n, CharT c)
+ void insert(iterator position, size_type n, CharT c)
 {
 this->insert(position, cvalue_iterator(c, n),
 cvalue_iterator());
@@ -1061,7 +1053,7 @@
 void insert(iterator p, InputIter first, InputIter last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_insert_dispatch(p, first, last, Result());
 }
@@ -1204,7 +1196,7 @@
 InputIter f, InputIter l)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 return this->priv_replace_dispatch(first, last, f, l, Result());
 }
@@ -1295,7 +1287,7 @@
 //! substring of *this, beginning at character position min(pos, size()).
 size_type rfind(const CharT* s, size_type pos, size_type n) const
 {
- const std::size_t len = size();
+ const size_type len = size();

 if (n > len)
 return npos;
@@ -1540,8 +1532,8 @@
 static int s_compare(const_pointer f1, const_pointer l1,
 const_pointer f2, const_pointer l2)
 {
- const std::ptrdiff_t n1 = l1 - f1;
- const std::ptrdiff_t n2 = l2 - f2;
+ const difference_type n1 = l1 - f1;
+ const difference_type n2 = l2 - f2;
 const int cmp = Traits::compare(containers_detail::get_pointer(f1),
 containers_detail::get_pointer(f2),
 containers_detail::min_value(n1, n2));
@@ -1900,19 +1892,19 @@
}

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

template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
 operator+(const basic_string<CharT,Traits,A>& x,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
 typedef typename basic_string<CharT,Traits,A>::size_type size_type;
 return my.replace(size_type(0), size_type(0), x);
@@ -1922,10 +1914,10 @@
inline basic_string<CharT,Traits,A>
operator+(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
- typedef basic_string<CharT,Traits,A> str_t;
+ typedef basic_string<CharT, Traits, A> str_t;
 typedef typename str_t::reserve_t reserve_t;
 reserve_t reserve;
- const std::size_t n = Traits::length(s);
+ const typename str_t::size_type n = Traits::length(s);
 str_t result(reserve, n + y.size());
 result.append(s, s + n);
 result.append(y);
@@ -1933,12 +1925,12 @@
}

template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(const CharT* s,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
 typedef typename basic_string<CharT,Traits,A>::size_type size_type;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(my.get().replace(size_type(0), size_type(0), s));
+ return boost::move(my.get().replace(size_type(0), size_type(0), s));
}

template <class CharT, class Traits, class A>
@@ -1955,9 +1947,9 @@
}

template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(CharT c,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
 typedef typename basic_string<CharT,Traits,A>::size_type size_type;
 return my.replace(size_type(0), size_type(0), &c, &c + 1);
@@ -1970,7 +1962,7 @@
 typedef basic_string<CharT,Traits,A> str_t;
 typedef typename str_t::reserve_t reserve_t;
 reserve_t reserve;
- const std::size_t n = Traits::length(s);
+ const typename str_t::size_type n = Traits::length(s);
 str_t result(reserve, x.size() + n, x.alloc());
 result.append(x);
 result.append(s, s + n);
@@ -1978,12 +1970,12 @@
}

template <class CharT, class Traits, class A>
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+operator+(BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
 , const CharT* s)
{
 mx += s;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
+ return boost::move(mx);
}

template <class CharT, class Traits, class A>
@@ -2000,12 +1992,12 @@
}

template <class CharT, class Traits, class A>
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+( BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+operator+( BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
 , const CharT c)
{
 mx += c;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
+ return boost::move(mx);
}

// Operator== and operator!=
@@ -2023,7 +2015,7 @@
inline bool
operator==(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
- std::size_t n = Traits::length(s);
+ typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
 return n == y.size() && Traits::compare(s, y.data(), n) == 0;
}

@@ -2031,7 +2023,7 @@
inline bool
operator==(const basic_string<CharT,Traits,A>& x, const CharT* s)
{
- std::size_t n = Traits::length(s);
+ typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
 return x.size() == n && Traits::compare(x.data(), s, n) == 0;
}

@@ -2068,7 +2060,7 @@
operator<(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
 return y.compare(s) > 0;
-// std::size_t n = Traits::length(s);
+// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
// return basic_string<CharT,Traits,A>
// ::s_compare(s, s + n, y.begin(), y.end()) < 0;
}
@@ -2079,7 +2071,7 @@
 const CharT* s)
{
 return x.compare(s) < 0;
-// std::size_t n = Traits::length(s);
+// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
// return basic_string<CharT,Traits,A>
// ::s_compare(x.begin(), x.end(), s, s + n) < 0;
}
@@ -2174,8 +2166,8 @@

 if (sentry) {
 ok = true;
- std::size_t n = s.size();
- std::size_t pad_len = 0;
+ typename basic_string<CharT,Traits,A>::size_type n = s.size();
+ typename basic_string<CharT,Traits,A>::size_type pad_len = 0;
 const bool left = (os.flags() & std::ios::left) != 0;
 const std::size_t w = os.width(0);
 std::basic_streambuf<CharT, Traits>* buf = os.rdbuf();
@@ -2251,7 +2243,7 @@
std::basic_istream<CharT, Traits>&
getline(std::istream& is, basic_string<CharT,Traits,A>& s,CharT delim)
{
- std::size_t nread = 0;
+ typename basic_string<CharT,Traits,A>::size_type nread = 0;
 typename std::basic_istream<CharT, Traits>::sentry sentry(is, true);
 if (sentry) {
 std::basic_streambuf<CharT, Traits>* buf = is.rdbuf();

Modified: sandbox/move/boost/container/vector.hpp
==============================================================================
--- sandbox/move/boost/container/vector.hpp (original)
+++ sandbox/move/boost/container/vector.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -31,6 +31,7 @@
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
+#include <boost/move/move_helpers.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
@@ -38,7 +39,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP
@@ -288,7 +289,7 @@
 (void)limit_size;
 (void)reuse;
 if(!(command & allocate_new))
- return std::pair<pointer, bool>(pointer(0), 0);
+ return std::pair<pointer, bool>(pointer(0), false);
 received_size = preferred_size;
 return std::make_pair(this->alloc().allocate(received_size), false);
 }
@@ -375,8 +376,6 @@
 /// @cond
 typedef vector<T, A> self_t;
 typedef containers_detail::vector_alloc_holder<A> base_t;
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
 /// @endcond
 public:
 //! The type of object, T, stored in the vector
@@ -411,7 +410,7 @@

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

@@ -421,7 +420,7 @@

 typedef constant_iterator<T, difference_type> cvalue_iterator;
 typedef repeat_iterator<T, difference_type> repeat_it;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<repeat_it> repeat_move_it;
+ typedef boost::move_iterator<repeat_it> repeat_move_it;
 /// @endcond

 public:
@@ -471,7 +470,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- vector(BOOST_MOVE_MACRO_RV_REF(vector) mx)
+ vector(BOOST_RV_REF(vector) mx)
 : base_t(static_cast<base_t&>(mx).alloc())
 { this->swap(mx); }

@@ -600,8 +599,8 @@

 //! Requires: !empty()
 //!
- //! Effects: Returns a reference to the first element
- //! from the beginning of the container.
+ //! Effects: Returns a reference to the first
+ //! element of the container.
 //!
 //! Throws: Nothing.
 //!
@@ -611,8 +610,8 @@

 //! Requires: !empty()
 //!
- //! Effects: Returns a const reference to the first element
- //! from the beginning of the container.
+ //! Effects: Returns a const reference to the first
+ //! element of the container.
 //!
 //! Throws: Nothing.
 //!
@@ -622,8 +621,8 @@

 //! Requires: !empty()
 //!
- //! Effects: Returns a reference to the first element
- //! from the beginning of the container.
+ //! Effects: Returns a reference to the last
+ //! element of the container.
 //!
 //! Throws: Nothing.
 //!
@@ -631,8 +630,10 @@
 reference back()
 { return this->members_.m_start[this->members_.m_size - 1]; }

- //! Effects: Returns a const reference to the first element
- //! from the beginning of the container.
+ //! Requires: !empty()
+ //!
+ //! Effects: Returns a const reference to the last
+ //! element of the container.
 //!
 //! Throws: Nothing.
 //!
@@ -754,7 +755,7 @@
 //! 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.
+ //! Throws: If memory allocation allocation throws or T's copy/move constructor throws.
 void reserve(size_type new_cap)
 {
 if (this->capacity() < new_cap){
@@ -780,8 +781,8 @@
 else{
 //We will reuse insert code, so create a dummy input iterator
 T *dummy_it(containers_detail::get_pointer(this->members_.m_start));
- containers_detail::advanced_insert_aux_proxy<T, BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<T*>, T*>
- proxy(::BOOST_CONTAINER_MOVE_NAMESPACE::make_move_iterator(dummy_it), ::BOOST_CONTAINER_MOVE_NAMESPACE::make_move_iterator(dummy_it));
+ containers_detail::advanced_insert_aux_proxy<T, boost::move_iterator<T*>, T*>
+ proxy(::boost::make_move_iterator(dummy_it), ::boost::make_move_iterator(dummy_it));
 //Backwards (and possibly forward) expansion
 if(ret.second){
 #ifdef BOOST_CONTAINERS_VECTOR_ALLOC_STATS
@@ -818,7 +819,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(vector) x)
+ vector& operator=(BOOST_COPY_ASSIGN_REF(vector) x)
 {
 if (&x != this){
 this->assign(x.members_.m_start, x.members_.m_start + x.members_.m_size);
@@ -834,7 +835,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Linear.
- vector& operator=(BOOST_MOVE_MACRO_RV_REF(vector) x)
+ vector& operator=(BOOST_RV_REF(vector) x)
 {
 if (&x != this){
 this->swap(x);
@@ -861,17 +862,32 @@
 void assign(InIt first, InIt last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_assign_dispatch(first, last, Result());
 }

+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
 //! 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.
+ void push_back(const T &x);
+
+ //! 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.
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
+ #endif
+
+/*
 void push_back(insert_const_ref_type x)
 { return priv_push_back(x); }

@@ -879,11 +895,13 @@
 void push_back(T &x) { push_back(const_cast<const T &>(x)); }

 template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c
- <containers_detail::is_same<T, U>::value &&
- !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value
- >::type* =0)
+ typename containers_detail::enable_if_c
+ <!::boost::has_move_emulation_enabled::value &&
+ containers_detail::is_same<T, U>::value
+ >::type
+ push_back(const U &u)
 { return priv_push_back(u); }
+
 #endif

 //! Effects: Constructs a new element in the end of the vector
@@ -892,17 +910,25 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_back(BOOST_MOVE_MACRO_RV_REF(T) x)
+ void push_back(BOOST_RV_REF(T) x)
 {
 if (this->members_.m_size < this->members_.m_capacity){
 //There is more memory, just construct a new object at the end
- new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
+ new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(::boost::move(x));
 ++this->members_.m_size;
 }
 else{
- this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
+ this->insert(this->cend(), ::boost::move(x));
 }
 }
+*/
+ //! 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.
+

 #if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

@@ -918,12 +944,12 @@
 T* back_pos = containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size;
 if (this->members_.m_size < this->members_.m_capacity){
 //There is more memory, just construct a new object at the end
- new((void*)(back_pos))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new((void*)(back_pos))value_type(::boost::forward<Args>(args)...);
 ++this->members_.m_size;
 }
 else{
 typedef containers_detail::advanced_insert_aux_emplace<T, T*, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(::boost::forward<Args>(args)...);
 priv_range_insert(back_pos, 1, proxy);
 }
 }
@@ -943,7 +969,7 @@
 //Just call more general insert(pos, size, value) and return iterator
 size_type pos_n = position - cbegin();
 typedef containers_detail::advanced_insert_aux_emplace<T, T*, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(::boost::forward<Args>(args)...);
 priv_range_insert(position.get_ptr(), 1, proxy);
 return iterator(this->members_.m_start + pos_n);
 }
@@ -974,30 +1000,30 @@

 #define BOOST_PP_LOCAL_MACRO(n) \
 template<BOOST_PP_ENUM_PARAMS(n, class P)> \
- void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
+ void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
 { \
 T* back_pos = containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size; \
 if (this->members_.m_size < this->members_.m_capacity){ \
 new((void*)(back_pos))value_type \
- (BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ (BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 ++this->members_.m_size; \
 } \
 else{ \
- containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
+ containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
 <value_type, T*, BOOST_PP_ENUM_PARAMS(n, P)> \
- proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
 priv_range_insert(back_pos, 1, proxy); \
 } \
 } \
 \
 template<BOOST_PP_ENUM_PARAMS(n, class P)> \
- iterator emplace(const_iterator pos, BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
+ iterator emplace(const_iterator pos, BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
 { \
 size_type pos_n = pos - cbegin(); \
- containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
+ containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
 <value_type, T*, BOOST_PP_ENUM_PARAMS(n, P)> \
- proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
- priv_range_insert(containers_detail::get_pointer(pos.get_ptr()), 1, proxy); \
+ proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ priv_range_insert(containers_detail::get_pointer(pos.get_ptr()), 1, proxy); \
 return iterator(this->members_.m_start + pos_n); \
 } \
 //!
@@ -1026,6 +1052,7 @@
 }
 }

+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
 //! Requires: position must be a valid iterator of *this.
 //!
 //! Effects: Insert a copy of x before position.
@@ -1034,16 +1061,7 @@
 //!
 //! Complexity: If position is end(), amortized constant time
 //! Linear time otherwise.
- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x) { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
+ iterator insert(const_iterator position, const T &x);

 //! Requires: position must be a valid iterator of *this.
 //!
@@ -1053,15 +1071,10 @@
 //!
 //! Complexity: If position is end(), amortized constant time
 //! Linear time otherwise.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x)
- {
- //Just call more general insert(pos, size, value) and return iterator
- size_type pos_n = position - cbegin();
- this->insert(position
- ,repeat_move_it(repeat_it(x, 1))
- ,repeat_move_it(repeat_it()));
- return iterator(this->members_.m_start + pos_n);
- }
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif

 //! Requires: pos must be a valid iterator of *this.
 //!
@@ -1075,7 +1088,7 @@
 void insert(const_iterator pos, InIt first, InIt last)
 {
 //Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIt, size_type>::value;
 typedef containers_detail::bool_<aux_boolean> Result;
 this->priv_insert_dispatch(pos, first, last, Result());
 }
@@ -1107,12 +1120,12 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the elements between pos and the
- //! last element. Constant if pos is the first or the last element.
+ //! last element. Constant if pos is the last element.
 iterator erase(const_iterator position)
 {
 T *pos = containers_detail::get_pointer(position.get_ptr());
 T *beg = containers_detail::get_pointer(this->members_.m_start);
- BOOST_CONTAINER_MOVE_NAMESPACE::move(pos + 1, beg + this->members_.m_size, pos);
+ ::boost::move(pos + 1, beg + this->members_.m_size, pos);
 --this->members_.m_size;
 //Destroy last element
 base_t::destroy(containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size);
@@ -1123,12 +1136,13 @@
 //!
 //! Throws: Nothing.
 //!
- //! Complexity: Linear to the distance between first and last.
+ //! Complexity: Linear to the distance between first and last
+ //! plus linear to the elements between pos and the last element.
 iterator erase(const_iterator first, const_iterator last)
 {
 if (first != last){ // worth doing, copy down over hole
 T* end_pos = containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size;
- T* ptr = containers_detail::get_pointer(BOOST_CONTAINER_MOVE_NAMESPACE::move
+ T* ptr = containers_detail::get_pointer(boost::move
 (containers_detail::get_pointer(last.get_ptr())
 ,end_pos
 ,containers_detail::get_pointer(first.get_ptr())
@@ -1190,7 +1204,7 @@
 //! 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.
+ //! Throws: If memory allocation throws, or T's copy/move constructor throws.
 //!
 //! Complexity: Linear to size().
 void shrink_to_fit()
@@ -1207,15 +1221,26 @@
 return iterator(this->members_.m_start + pos_n);
 }

- void priv_push_back(const T &x)
+ iterator priv_insert(const_iterator position, BOOST_RV_REF(T) x)
+ {
+ //Just call more general insert(pos, size, value) and return iterator
+ size_type pos_n = position - cbegin();
+ this->insert(position
+ ,repeat_move_it(repeat_it(x, 1))
+ ,repeat_move_it(repeat_it()));
+ return iterator(this->members_.m_start + pos_n);
+ }
+
+ template <class U>
+ void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x)
 {
 if (this->members_.m_size < this->members_.m_capacity){
 //There is more memory, just construct a new object at the end
- new((void*)(containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size))value_type(x);
+ new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(::boost::forward(x));
 ++this->members_.m_size;
 }
 else{
- this->insert(this->cend(), x);
+ this->insert(this->cend(), ::boost::forward(x));
 }
 }

@@ -1226,8 +1251,29 @@
 this->prot_deallocate();
 }
 else{
- //This would not work with stateful allocators
- vector<T, A>(*this).swap(*this);
+ //Allocate a new buffer.
+ size_type real_cap = 0;
+ std::pair<pointer, bool> ret =
+ this->allocation_command
+ (allocate_new, this->size(), this->size(), real_cap, this->members_.m_start);
+ if(real_cap < this->capacity()){
+ //We will reuse insert code, so create a dummy input iterator
+ T *dummy_it(containers_detail::get_pointer(this->members_.m_start));
+ containers_detail::advanced_insert_aux_proxy<T, boost::move_iterator<T*>, T*>
+ proxy(::boost::make_move_iterator(dummy_it), ::boost::make_move_iterator(dummy_it));
+ #ifdef BOOST_CONTAINERS_VECTOR_ALLOC_STATS
+ ++this->num_alloc;
+ #endif
+ this->priv_range_insert_new_allocation
+ ( containers_detail::get_pointer(ret.first)
+ , real_cap
+ , containers_detail::get_pointer(this->members_.m_start)
+ , 0
+ , proxy);
+ }
+ else{
+ this->alloc().deallocate(ret.first, real_cap);
+ }
 }
 }
 }
@@ -1335,10 +1381,10 @@
 if (elems_after > n){
 //New elements can be just copied.
 //Move to uninitialized memory last objects
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_finish - n, old_finish, old_finish);
+ ::boost::uninitialized_move(old_finish - n, old_finish, old_finish);
 this->members_.m_size += n;
 //Copy previous to last objects to the initialized end
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, old_finish - n, old_finish);
+ boost::move_backward(pos, old_finish - n, old_finish);
 //Insert new objects in the pos
 interf.copy_all_to(pos);
 }
@@ -1348,7 +1394,7 @@
 interf.uninitialized_copy_some_and_update(old_finish, elems_after, false);
 this->members_.m_size += n - elems_after;
 //Copy old [pos, end()) elements to the uninitialized memory
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ ::boost::uninitialized_move
 ( pos, old_finish, containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size);
 this->members_.m_size += elems_after;
 //Copy first new elements in pos
@@ -1370,7 +1416,7 @@
 //the start of the new buffer
 T *old_buffer = containers_detail::get_pointer(this->members_.m_start);
 if(old_buffer){
- new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ new_finish = ::boost::uninitialized_move
 (containers_detail::get_pointer(this->members_.m_start), pos, old_finish = new_finish);
 constructed_values_destroyer.increment_size(new_finish - old_finish);
 }
@@ -1381,7 +1427,7 @@
 //Initialize from the rest of the old buffer,
 //starting from previous point
 if(old_buffer){
- new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ new_finish = ::boost::uninitialized_move
 (pos, old_buffer + this->members_.m_size, new_finish);
 //Destroy and deallocate old elements
 //If there is allocated memory, destroy and deallocate
@@ -1422,7 +1468,7 @@
 //Check if s_before is big enough to hold the beginning of old data + new data
 if(difference_type(s_before) >= difference_type(elemsbefore + n)){
 //Copy first old values before pos, after that the new objects
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
 this->members_.m_size = elemsbefore;
 interf.uninitialized_copy_all_to(new_start + elemsbefore);
 this->members_.m_size += n;
@@ -1440,7 +1486,7 @@
 //|___________|__________|_________|________________________|
 //
 //Now initialize the rest of memory with the last old values
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ ::boost::uninitialized_move
 (pos, old_finish, new_start + elemsbefore + n);
 //All new elements correctly constructed, avoid new element destruction
 this->members_.m_size = old_size + n;
@@ -1467,13 +1513,13 @@
 size_type raw_gap = s_before - (elemsbefore + n);
 //Now initialize the rest of s_before memory with the
 //first of elements after new values
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, pos + raw_gap, new_start + elemsbefore + n);
+ ::boost::uninitialized_move(pos, pos + raw_gap, new_start + elemsbefore + n);
 //Update size since we have a contiguous buffer
 this->members_.m_size = old_size + s_before;
 //All new elements correctly constructed, avoid old element destruction
 old_values_destroyer.release();
 //Now copy remaining last objects in the old buffer begin
- T *to_destroy = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos + raw_gap, old_finish, old_start);
+ T *to_destroy = ::boost::move(pos + raw_gap, old_finish, old_start);
 //Now destroy redundant elements except if they were moved and
 //they have trivial destructor after move
 size_type n_destroy = old_finish - to_destroy;
@@ -1532,13 +1578,13 @@
 //
 //Copy the first part of old_begin to raw_mem
 T *start_n = old_start + difference_type(s_before);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, start_n, new_start);
+ ::boost::uninitialized_move(old_start, start_n, new_start);
 //The buffer is all constructed until old_end,
 //release destroyer and update size
 old_values_destroyer.release();
 this->members_.m_size = old_size + s_before;
 //Now copy the second part of old_begin overwriting himself
- T* next = BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
+ T* next = ::boost::move(start_n, pos, old_start);
 if(do_after){
 //Now copy the new_beg elements
 interf.copy_some_and_update(next, s_before, true);
@@ -1548,7 +1594,7 @@
 interf.copy_all_to(next);
 T* move_start = next + n;
 //Now displace old_end elements
- T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos, old_finish, move_start);
+ T* move_end = ::boost::move(pos, old_finish, move_start);
 //Destroy remaining moved elements from old_end except if
 //they have trivial destructor after being moved
 difference_type n_destroy = s_before - n;
@@ -1584,7 +1630,7 @@
 //|___________|_____|_________|__________________________|
 //
 //First copy whole old_begin and part of new to raw_mem
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
 this->members_.m_size = elemsbefore;

 const size_type mid_n = difference_type(s_before) - elemsbefore;
@@ -1603,7 +1649,7 @@
 interf.copy_all_to(old_start);
 T* move_start = old_start + (n-mid_n);
 //Displace old_end
- T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos, old_finish, move_start);
+ T* move_end = ::boost::move(pos, old_finish, move_start);
 //Destroy remaining moved elements from old_end except if they
 //have trivial destructor after being moved
 difference_type n_destroy = s_before - n;
@@ -1654,10 +1700,10 @@
 //
 //First copy the part of old_end raw_mem
 T* finish_n = old_finish - difference_type(n_after);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(finish_n, old_finish, old_finish);
+ ::boost::uninitialized_move(finish_n, old_finish, old_finish);
 this->members_.m_size += n_after;
 //Displace the rest of old_end to the new position
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, finish_n, old_finish);
+ boost::move_backward(pos, finish_n, old_finish);
 //Now overwrite with new_end
 //The new_end part is [first + (n - n_after), last)
 interf.copy_all_to(pos);
@@ -1680,7 +1726,7 @@
 //The new_end part is [first + (n - n_after), last)
 interf.uninitialized_copy_some_and_update(old_finish, elemsafter, false);
 this->members_.m_size += mid_last_dist;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, old_finish, old_finish + mid_last_dist);
+ ::boost::uninitialized_move(pos, old_finish, old_finish + mid_last_dist);
 this->members_.m_size += n_after - mid_last_dist;
 //Now copy the part of new_end over constructed elements
 interf.copy_all_to(pos);
@@ -1693,7 +1739,7 @@
 void priv_range_insert(const_iterator pos, InIt first, InIt last, std::input_iterator_tag)
 {
 for(;first != last; ++first){
- this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
+ this->insert(pos, ::boost::move(value_type(*first)));
 }
 }

@@ -1764,14 +1810,14 @@
 T *end = std::copy(first, mid, start);
 //Initialize the remaining new elements in the uninitialized memory
 // iG std::uninitialized_copy(mid, last, end);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(mid, last, end);
+ ::boost::uninitialized_copy_or_move(mid, last, end);
 this->members_.m_size = n;
 }
 }
 else if(!ret.second){
 typename value_traits::UCopiedArrayDeallocator scoped_alloc(ret.first, this->alloc(), real_cap);
 // iG std::uninitialized_copy(first, last, containers_detail::get_pointer(ret.first));
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, last, containers_detail::get_pointer(ret.first));
+ ::boost::uninitialized_copy_or_move(first, last, containers_detail::get_pointer(ret.first));
 scoped_alloc.release();
 //Destroy and deallocate old buffer
 if(this->members_.m_start != 0){
@@ -1801,7 +1847,7 @@
 FwdIt mid = first;
 std::advance(mid, first_count);
 // iG std::uninitialized_copy(first, mid, containers_detail::get_pointer(ret.first));
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, mid, containers_detail::get_pointer(ret.first));
+ ::boost::uninitialized_copy_or_move(first, mid, containers_detail::get_pointer(ret.first));

 if(old_offset > n){
 //All old elements will be destroyed by "old_values_destroyer"
@@ -1839,7 +1885,7 @@

 template <class Integer>
 void priv_assign_dispatch(Integer n, Integer val, containers_detail::true_)
- { this->assign((size_type) n, val); }
+ { this->assign((size_type) n, (value_type)val); }

 template <class InIt>
 void priv_assign_dispatch(InIt first, InIt last, containers_detail::false_)

Modified: sandbox/move/boost/intrusive/avl_set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/avl_set.hpp (original)
+++ sandbox/move/boost/intrusive/avl_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/avltree.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/move/move.hpp>
#include <iterator>

namespace boost {
@@ -42,12 +43,8 @@
 /// @cond
 typedef avltree_impl<Config> tree_type;
 //! This class is
- //! non-copyable
- avl_set_impl (const avl_set_impl&);
-
- //! This class is
- //! non-assignable
- avl_set_impl &operator =(const avl_set_impl&);
+ //! movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set_impl)

 typedef tree_type implementation_defined;
 /// @endcond
@@ -113,6 +110,17 @@
 : tree_(true, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ avl_set_impl(BOOST_RV_REF(avl_set_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ avl_set_impl& operator=(BOOST_RV_REF(avl_set_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the avl_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1181,6 +1189,7 @@
 #endif
 ::type Base;

+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set)
 public:
 typedef typename Base::value_compare value_compare;
 typedef typename Base::value_traits value_traits;
@@ -1202,6 +1211,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ avl_set(BOOST_RV_REF(avl_set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ avl_set& operator=(BOOST_RV_REF(avl_set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static avl_set &container_from_end_iterator(iterator end_iterator)
 { return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); }

@@ -1238,9 +1254,8 @@
 /// @cond
 typedef avltree_impl<Config> tree_type;

- //Non-copyable and non-assignable
- avl_multiset_impl (const avl_multiset_impl&);
- avl_multiset_impl &operator =(const avl_multiset_impl&);
+ //Movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset_impl)
 typedef tree_type implementation_defined;
 /// @endcond

@@ -1305,6 +1320,17 @@
 : tree_(false, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ avl_multiset_impl(BOOST_RV_REF(avl_multiset_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ avl_multiset_impl& operator=(BOOST_RV_REF(avl_multiset_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the avl_multiset
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2280,6 +2306,7 @@
 #endif
 ::type Base;

+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset)
 public:
 typedef typename Base::value_compare value_compare;
 typedef typename Base::value_traits value_traits;
@@ -2301,6 +2328,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ avl_multiset(BOOST_RV_REF(avl_multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static avl_multiset &container_from_end_iterator(iterator end_iterator)
 { return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/avltree.hpp
==============================================================================
--- sandbox/move/boost/intrusive/avltree.hpp (original)
+++ sandbox/move/boost/intrusive/avltree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -32,6 +32,7 @@
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/avltree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -122,9 +123,8 @@
 private:
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

- //noncopyable
- avltree_impl (const avltree_impl&);
- avltree_impl operator =(const avltree_impl&);
+ //noncopyable, movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -159,6 +159,12 @@
 value_compare &priv_comp()
 { return data_.node_plus_pred_.get(); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 const node &priv_header() const
 { return data_.node_plus_pred_.header_plus_size_.header_; }

@@ -241,6 +247,21 @@
 this->insert_equal(b, e);
 }

+ //! Effects: to-do
+ //!
+ avltree_impl(BOOST_RV_REF(avltree_impl) x)
+ : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
+ {
+ node_algorithms::init_header(&priv_header());
+ this->priv_size_traits().set_size(size_type(0));
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ avltree_impl& operator=(BOOST_RV_REF(avltree_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called), but the nodes according to
 //! the value_traits template parameter are reinitialized and thus can be reused.
@@ -465,9 +486,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal_upper_bound
+ iterator ret(node_algorithms::insert_equal_upper_bound
 (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and "hint" must be
@@ -491,9 +513,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal
+ iterator ret(node_algorithms::insert_equal
 (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: Dereferencing iterator must yield an lvalue
@@ -698,9 +721,9 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::insert_unique_commit
 (node_ptr(&priv_header()), to_insert, commit_data);
+ this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }

@@ -723,9 +746,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_before
+ iterator ret(node_algorithms::insert_before
 (node_ptr(&priv_header()), pos.pointed_node(), to_insert), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and it must be no less
@@ -747,8 +771,8 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::push_back(node_ptr(&priv_header()), to_insert);
+ this->priv_size_traits().increment();
 }

 //! Requires: value must be an lvalue, and it must be no greater
@@ -770,8 +794,8 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::push_front(node_ptr(&priv_header()), to_insert);
+ this->priv_size_traits().increment();
 }

 //! Effects: Erases the element pointed to by pos.
@@ -1271,6 +1295,8 @@
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
 , node_ptr(&priv_header())
 , get_real_value_traits().to_node_ptr(with_this));
+ if(safemode_or_autounlink)
+ node_algorithms::init(replace_this.pointed_node());
 }

 //! Requires: value must be an lvalue and shall be in a set of
@@ -1601,6 +1627,8 @@
 #endif
 ::type Base;

+ BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree)
+
 public:
 typedef typename Base::value_compare value_compare;
 typedef typename Base::value_traits value_traits;
@@ -1623,6 +1651,13 @@
 : Base(unique, b, e, cmp, v_traits)
 {}

+ avltree(BOOST_RV_REF(avltree) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ avltree& operator=(BOOST_RV_REF(avltree) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static avltree &container_from_end_iterator(iterator end_iterator)
 { return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/circular_slist_algorithms.hpp
==============================================================================
--- sandbox/move/boost/intrusive/circular_slist_algorithms.hpp (original)
+++ sandbox/move/boost/intrusive/circular_slist_algorithms.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -63,7 +63,7 @@

 //! Effects: Constructs an non-used list element, putting the next
 //! pointer to null:
- //! <tt>NodeTraits::get_next(this_node) == 0
+ //! <tt>NodeTraits::get_next(this_node) == 0</tt>
 //!
 //! Complexity: Constant
 //!

Modified: sandbox/move/boost/intrusive/derivation_value_traits.hpp
==============================================================================
--- sandbox/move/boost/intrusive/derivation_value_traits.hpp (original)
+++ sandbox/move/boost/intrusive/derivation_value_traits.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -46,14 +46,18 @@

 static pointer to_value_ptr(node_ptr n)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<value_type>(n));
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<value_type>(n));
+ return pointer(&static_cast<value_type&>(*n));
 }

 static const_pointer to_value_ptr(const_node_ptr n)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<const value_type>(n));
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<const value_type>(n));
+ return const_pointer(&static_cast<const value_type&>(*n));
 }
};

Modified: sandbox/move/boost/intrusive/detail/hashtable_node.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/hashtable_node.hpp (original)
+++ sandbox/move/boost/intrusive/detail/hashtable_node.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -23,6 +23,9 @@
#include <boost/intrusive/detail/slist_node.hpp> //remove-me
#include <cstddef>
#include <boost/pointer_cast.hpp>
+#include <boost/move/move.hpp>
+
+
namespace boost {
namespace intrusive {
namespace detail {
@@ -76,6 +79,10 @@
template<class Slist>
struct bucket_traits_impl
{
+ private:
+ BOOST_COPYABLE_AND_MOVABLE(bucket_traits_impl)
+
+ public:
 /// @cond
 typedef typename boost::pointer_to_other
 < typename Slist::pointer, bucket_impl<Slist> >::type bucket_ptr;
@@ -86,6 +93,21 @@
 : buckets_(buckets), buckets_len_(len)
 {}

+ bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
+ : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
+ { x.buckets_ = bucket_ptr(0); x.buckets_len_ = 0; }
+
+ bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
+ {
+ buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
+ x.buckets_ = bucket_ptr(0); x.buckets_len_ = 0; return *this;
+ }
+
+ bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
+ {
+ buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; return *this;
+ }
+
 bucket_ptr bucket_begin() const
 { return buckets_; }

@@ -119,8 +141,10 @@

 static typename Container::node_ptr downcast_bucket(typename bucket_type::node_ptr p)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<typename Container::node>(p);
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<typename Container::node>(p);
+ return typename Container::node_ptr(&static_cast<typename Container::node&>(*p));
 }

 public:

Modified: sandbox/move/boost/intrusive/detail/mpl.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/mpl.hpp (original)
+++ sandbox/move/boost/intrusive/detail/mpl.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -138,6 +138,10 @@
struct is_unary_or_binary_function_impl
{ static const bool value = false; };

+// see boost ticket #4094
+// avoid duplicate definitions of is_unary_or_binary_function_impl
+#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
+
template <typename R>
struct is_unary_or_binary_function_impl<R (*)()>
{ static const bool value = true; };
@@ -145,19 +149,11 @@
template <typename R>
struct is_unary_or_binary_function_impl<R (*)(...)>
{ static const bool value = true; };
-/*
-#ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
-
-template <typename R>
-struct is_unary_or_binary_function_impl<R (__stdcall*)()>
-{ static const bool value = true; };

-template <typename R>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(...)>
-{ static const bool value = true; };
+#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS

template <typename R>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(...)>
+struct is_unary_or_binary_function_impl<R (__stdcall*)()>
{ static const bool value = true; };

template <typename R>
@@ -165,18 +161,19 @@
{ static const bool value = true; };

template <typename R>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(...)>
-{ static const bool value = true; };
-
-template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)()>
{ static const bool value = true; };

template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)(...)>
{ static const bool value = true; };
+
#endif
-*/
+
+// see boost ticket #4094
+// avoid duplicate definitions of is_unary_or_binary_function_impl
+#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
+
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0)>
{ static const bool value = true; };
@@ -185,34 +182,30 @@
struct is_unary_or_binary_function_impl<R (*)(T0...)>
{ static const bool value = true; };

-#ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
+#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS

template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)>
{ static const bool value = true; };
-/*
-template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0...)>
-{ static const bool value = true; };

template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)>
{ static const bool value = true; };

template <typename R, class T0>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0...)>
-{ static const bool value = true; };
-
-template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)>
{ static const bool value = true; };

template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)>
{ static const bool value = true; };
-*/
+
#endif

+// see boost ticket #4094
+// avoid duplicate definitions of is_unary_or_binary_function_impl
+#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
+
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
{ static const bool value = true; };
@@ -220,15 +213,11 @@
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
{ static const bool value = true; };
-/*
-#ifdef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS

-template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
-{ static const bool value = true; };
+#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS

template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1...)>
+struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
{ static const bool value = true; };

template <typename R, class T0, class T1>
@@ -236,10 +225,6 @@
{ static const bool value = true; };

template <typename R, class T0, class T1>
-struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1...)>
-{ static const bool value = true; };
-
-template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
{ static const bool value = true; };

@@ -247,7 +232,7 @@
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)>
{ static const bool value = true; };
#endif
-*/
+
template <typename T>
struct is_unary_or_binary_function_impl<T&>
{ static const bool value = false; };

Modified: sandbox/move/boost/intrusive/detail/parent_from_member.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/parent_from_member.hpp (original)
+++ sandbox/move/boost/intrusive/detail/parent_from_member.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -9,8 +9,8 @@
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_INTRUSIVE_PARENT_FROM_MEMBER_HPP
-#define BOOST_INTRUSIVE_PARENT_FROM_MEMBER_HPP
+#ifndef BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP
+#define BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP

#include <boost/intrusive/detail/config_begin.hpp>
#include <cstddef>
@@ -47,15 +47,13 @@
template<class Parent, class Member>
inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{
- return (Parent*)((char*)member -
- offset_from_pointer_to_member(ptr_to_member));
+ return (Parent*)((char*)member - offset_from_pointer_to_member(ptr_to_member));
}

template<class Parent, class Member>
inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{
- return (const Parent*)((const char*)member -
- offset_from_pointer_to_member(ptr_to_member));
+ return (const Parent*)((const char*)member - offset_from_pointer_to_member(ptr_to_member));
}

} //namespace detail {
@@ -68,4 +66,4 @@

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

-#endif //#ifndef BOOST_INTRUSIVE_PARENT_FROM_MEMBER_HPP
+#endif //#ifndef BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP

Modified: sandbox/move/boost/intrusive/detail/transform_iterator.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/transform_iterator.hpp (original)
+++ sandbox/move/boost/intrusive/detail/transform_iterator.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -46,7 +46,7 @@
// This function is needed for MWCW and BCC, which won't call operator->
// again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; }
- mutable T &m_value;
+ T &m_value;
};

template <class Iterator, class UnaryFunction>

Modified: sandbox/move/boost/intrusive/detail/tree_node.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/tree_node.hpp (original)
+++ sandbox/move/boost/intrusive/detail/tree_node.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -96,7 +96,7 @@

    tree_iterator()
- : members_ (0, 0)
+ : members_ (node_ptr(0), (const void *)0)
    {}

    explicit tree_iterator(node_ptr nodeptr, const Container *cont_ptr)

Modified: sandbox/move/boost/intrusive/detail/utilities.hpp
==============================================================================
--- sandbox/move/boost/intrusive/detail/utilities.hpp (original)
+++ sandbox/move/boost/intrusive/detail/utilities.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -207,32 +207,33 @@
 : private detail::ebo_functor_holder<KeyValueCompare>
{
 typedef typename Container::real_value_traits real_value_traits;
+ typedef typename Container::value_type value_type;
 typedef typename real_value_traits::node_ptr node_ptr;
 typedef typename real_value_traits::const_node_ptr const_node_ptr;
 typedef detail::ebo_functor_holder<KeyValueCompare> base_t;
 key_nodeptr_comp(KeyValueCompare kcomp, const Container *cont)
 : base_t(kcomp), cont_(cont)
 {}
+
+ template<class T>
+ struct is_node_ptr
+ {
+ static const bool value = is_same<T, const_node_ptr>::value || is_same<T, node_ptr>::value;
+ };

- template<class KeyType>
- bool operator()( const_node_ptr node, const KeyType &key
- , typename enable_if_c
- <!is_convertible<KeyType, const_node_ptr>::value>::type * = 0) const
- { return base_t::get()(*cont_->get_real_value_traits().to_value_ptr(node), key); }
-
- template<class KeyType>
- bool operator()(const KeyType &key, const_node_ptr node
- , typename enable_if_c
- <!is_convertible<KeyType, const_node_ptr>::value>::type * = 0) const
- { return base_t::get()(key, *cont_->get_real_value_traits().to_value_ptr(node)); }
-
- bool operator()(const_node_ptr node1, const_node_ptr node2) const
- {
- return base_t::get()
- ( *cont_->get_real_value_traits().to_value_ptr(node1)
- , *cont_->get_real_value_traits().to_value_ptr(node2)
- );
- }
+ template<class T>
+ typename enable_if_c<is_node_ptr<T>::value, const value_type &>::type
+ key_forward(const T &node) const
+ { return *cont_->get_real_value_traits().to_value_ptr(node); }
+
+ template<class T>
+ typename enable_if_c<!is_node_ptr<T>::value, const T &>::type
+ key_forward(const T &key) const
+ { return key;}
+
+ template<class KeyType, class KeyType2>
+ bool operator()(const KeyType &key1, const KeyType2 &key2) const
+ { return base_t::get()(this->key_forward(key1), this->key_forward(key2)); }

 const Container *cont_;
};
@@ -410,14 +411,10 @@
 static const link_mode_type link_mode = Hook::boost_intrusive_tags::link_mode;

 static node_ptr to_node_ptr(reference value)
- {
- return reinterpret_cast<node*>(&(value.*P));
- }
+ { return static_cast<node*>(&(value.*P)); }

 static const_node_ptr to_node_ptr(const_reference value)
- {
- return static_cast<const node*>(&(value.*P));
- }
+ { return static_cast<const node*>(&(value.*P)); }

 static pointer to_value_ptr(node_ptr n)
 {
@@ -432,6 +429,45 @@
 }
};

+template<class Functor>
+struct function_hook_traits
+{
+ public:
+ typedef typename Functor::hook_type hook_type;
+ typedef typename Functor::hook_ptr hook_ptr;
+ typedef typename Functor::const_hook_ptr const_hook_ptr;
+ typedef typename hook_type::boost_intrusive_tags::node_traits node_traits;
+ typedef typename node_traits::node node;
+ typedef typename Functor::value_type value_type;
+ typedef typename node_traits::node_ptr node_ptr;
+ typedef typename node_traits::const_node_ptr const_node_ptr;
+ typedef typename boost::pointer_to_other<node_ptr, value_type>::type pointer;
+ typedef typename boost::pointer_to_other<node_ptr, const value_type>::type const_pointer;
+ typedef typename std::iterator_traits<pointer>::reference reference;
+ typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ static const link_mode_type link_mode = hook_type::boost_intrusive_tags::link_mode;
+
+ static node_ptr to_node_ptr(reference value)
+ { return static_cast<node*>(&*Functor::to_hook_ptr(value)); }
+
+ static const_node_ptr to_node_ptr(const_reference value)
+ { return static_cast<const node*>(&*Functor::to_hook_ptr(value)); }
+
+ static pointer to_value_ptr(node_ptr n)
+ { return Functor::to_value_ptr(to_hook_ptr(n)); }
+
+ static const_pointer to_value_ptr(const_node_ptr n)
+ { return Functor::to_value_ptr(to_hook_ptr(n)); }
+
+ private:
+ static hook_ptr to_hook_ptr(node_ptr n)
+ { return hook_ptr(&*static_cast<hook_type*>(&*n)); }
+
+ static const_hook_ptr to_hook_ptr(const_node_ptr n)
+ { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
+};
+
+
//This function uses binary search to discover the
//highest set bit of the integer
inline std::size_t floor_log2 (std::size_t x)
@@ -454,14 +490,19 @@

inline float fast_log2 (float val)
{
- boost::uint32_t * exp_ptr =
- static_cast<boost::uint32_t *>(static_cast<void*>(&val));
- boost::uint32_t x = *exp_ptr;
+ union caster_t
+ {
+ boost::uint32_t x;
+ float val;
+ } caster;
+
+ caster.val = val;
+ boost::uint32_t x = caster.x;
 const int log_2 = (int)(((x >> 23) & 255) - 128);
 x &= ~(255 << 23);
 x += 127 << 23;
- *exp_ptr = x;
-
+ caster.x = x;
+ val = caster.val;
 val = ((-1.0f/3) * val + 2) * val - 2.0f/3;

 return (val + log_2);

Modified: sandbox/move/boost/intrusive/hashtable.hpp
==============================================================================
--- sandbox/move/boost/intrusive/hashtable.hpp (original)
+++ sandbox/move/boost/intrusive/hashtable.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -37,6 +37,8 @@
#include <boost/intrusive/unordered_set_hook.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -123,7 +125,7 @@
 < typename NodeTraits::node
 , boost::intrusive::value_traits<trivial_traits>
 , boost::intrusive::constant_time_size<false>
- , boost::intrusive::size_type<std::size_t>
+ , boost::intrusive::size_type<typename boost::make_unsigned<typename std::iterator_traits<typename NodeTraits::node_ptr>::difference_type>::type>
>::type
 {};
};
@@ -158,26 +160,22 @@
template<class SupposedValueTraits>
struct unordered_bucket_impl
{
- /// @cond
 typedef typename
 get_slist_impl_from_supposed_value_traits
 <SupposedValueTraits>::type slist_impl;
 typedef detail::bucket_impl<slist_impl> implementation_defined;
- /// @endcond
 typedef implementation_defined type;
};

template<class SupposedValueTraits>
struct unordered_bucket_ptr_impl
{
- /// @cond
 typedef typename detail::get_node_traits
 <SupposedValueTraits>::type::node_ptr node_ptr;
 typedef typename unordered_bucket_impl
 <SupposedValueTraits>::type bucket_type;
 typedef typename boost::pointer_to_other
 <node_ptr, bucket_type>::type implementation_defined;
- /// @endcond
 typedef implementation_defined type;
};

@@ -215,7 +213,7 @@

template<class Config>
struct bucket_plus_size
- : public detail::size_holder
+ : public detail::size_holder //size_traits
 < 0 != (Config::bool_flags & hash_bool_flags::constant_time_size_pos)
 , typename Config::size_type>
{
@@ -224,15 +222,23 @@
 , typename Config::size_type> size_traits;
 typedef typename Config::bucket_traits bucket_traits;

- bucket_plus_size(const bucket_traits &b_traits)
- : bucket_traits_(b_traits)
+ template<class BucketTraits>
+ bucket_plus_size(BOOST_FWD_REF(BucketTraits) b_traits)
+ : bucket_traits_(::boost::forward<BucketTraits>(b_traits))
 {}
+
+ bucket_plus_size & operator =(const bucket_plus_size &x)
+ {
+ this->size_traits::operator=(x);
+ bucket_traits_ = x.bucket_traits_;
+ return *this;
+ }
 bucket_traits bucket_traits_;
};

template<class Config>
struct bucket_hash_t
- : public detail::ebo_functor_holder<typename Config::hash>
+ : public detail::ebo_functor_holder<typename Config::hash> //hash
{
 typedef typename Config::hash hasher;
 typedef detail::size_holder
@@ -240,22 +246,26 @@
 , typename Config::size_type> size_traits;
 typedef typename Config::bucket_traits bucket_traits;

- bucket_hash_t(const bucket_traits &b_traits, const hasher & h)
- : detail::ebo_functor_holder<hasher>(h), bucket_plus_size_(b_traits)
+ template<class BucketTraits>
+ bucket_hash_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h)
+ : detail::ebo_functor_holder<hasher>(h), bucket_plus_size_(::boost::forward<BucketTraits>(b_traits))
 {}

 bucket_plus_size<Config> bucket_plus_size_;
};

template<class Config, bool>
-struct bucket_hash_equal_t : public detail::ebo_functor_holder<typename Config::equal>
+struct bucket_hash_equal_t
+ : public detail::ebo_functor_holder<typename Config::equal>
{
 typedef typename Config::equal equal;
 typedef typename Config::hash hasher;
 typedef typename Config::bucket_traits bucket_traits;

- bucket_hash_equal_t(const bucket_traits &b_traits, const hasher & h, const equal &e)
- : detail::ebo_functor_holder<typename Config::equal>(e), bucket_hash(b_traits, h)
+ template<class BucketTraits>
+ bucket_hash_equal_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e)
+ : detail::ebo_functor_holder<typename Config::equal>(e)//equal()
+ , bucket_hash(::boost::forward<BucketTraits>(b_traits), h)
 {}
 bucket_hash_t<Config> bucket_hash;
};
@@ -270,8 +280,10 @@
 typedef typename unordered_bucket_ptr_impl
 <typename Config::value_traits>::type bucket_ptr;

- bucket_hash_equal_t(const bucket_traits &b_traits, const hasher & h, const equal &e)
- : detail::ebo_functor_holder<typename Config::equal>(e), bucket_hash(b_traits, h)
+ template<class BucketTraits>
+ bucket_hash_equal_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e)
+ : detail::ebo_functor_holder<typename Config::equal>(e) //equal()
+ , bucket_hash(::boost::forward<BucketTraits>(b_traits), h)
 {}
 bucket_hash_t<Config> bucket_hash;
 bucket_ptr cached_begin_;
@@ -286,22 +298,25 @@
 typedef typename Config::hash hasher;
 typedef typename Config::bucket_traits bucket_traits;

- hashtable_data_t( const bucket_traits &b_traits, const hasher & h
+ template<class BucketTraits>
+ hashtable_data_t( BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h
 , const equal &e, const value_traits &val_traits)
- : Config::value_traits(val_traits), internal_(b_traits, h, e)
+ : Config::value_traits(val_traits) //value_traits
+ , internal_(::boost::forward<BucketTraits>(b_traits), h, e)
 {}
 typedef typename detail::usetopt_mask
 < Config
 , detail::hash_bool_flags::constant_time_size_pos
- | detail::hash_bool_flags::incremental_pos
+ | detail::hash_bool_flags::incremental_pos
>::type masked_config_t;
 struct internal
- : public detail::size_holder
+ : public detail::size_holder //split_traits
 < 0 != (Config::bool_flags & hash_bool_flags::incremental_pos)
 , typename Config::size_type>
 {
- internal(const bucket_traits &b_traits, const hasher & h, const equal &e)
- : bucket_hash_equal_(b_traits, h, e)
+ template<class BucketTraits>
+ internal(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e)
+ : bucket_hash_equal_(::boost::forward<BucketTraits>(b_traits), h, e)
 {}

 bucket_hash_equal_t
@@ -331,8 +346,10 @@

 static node_ptr dcast_bucket_ptr(slist_node_ptr p)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<node>(p);
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<node>(p);
+ return node_ptr(&static_cast<node&>(*p));
 }

 static slist_node_ptr priv_get_bucket_before_begin
@@ -500,7 +517,6 @@
template<class ValueTraitsOrHookOption>
struct unordered_default_bucket_traits
{
- /// @cond
 typedef typename ValueTraitsOrHookOption::
 template pack<none>::value_traits supposed_value_traits;
 typedef typename detail::
@@ -508,7 +524,6 @@
 <supposed_value_traits>::type slist_impl;
 typedef detail::bucket_traits_impl
 <slist_impl> implementation_defined;
- /// @endcond
 typedef implementation_defined type;
};

@@ -710,9 +725,8 @@
 };

 private:
- //noncopyable
- hashtable_impl (const hashtable_impl&);
- hashtable_impl operator =(const hashtable_impl&);
+ //noncopyable, movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(hashtable_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -794,6 +808,33 @@
 priv_split_traits().set_size(bucket_size>>1);
 }

+ //! Effects: to-do
+ //!
+ hashtable_impl(BOOST_RV_REF(hashtable_impl) x)
+ : data_( ::boost::move(x.priv_bucket_traits())
+ , ::boost::move(x.priv_hasher())
+ , ::boost::move(x.priv_equal())
+ , ::boost::move(x.priv_value_traits())
+ )
+ {
+ priv_swap_cache(cache_begin_t(), x);
+ x.priv_initialize_cache();
+ if(constant_time_size){
+ this->priv_size_traits().set_size(size_type(0));
+ this->priv_size_traits().set_size(x.priv_size_traits().get_size());
+ x.priv_size_traits().set_size(size_type(0));
+ }
+ if(incremental){
+ this->priv_split_traits().set_size(x.priv_split_traits().get_size());
+ x.priv_split_traits().set_size(size_type(0));
+ }
+ }
+
+ //! Effects: to-do
+ //!
+ hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the unordered_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -938,14 +979,15 @@
 swap(this->priv_equal(), other.priv_equal());
 swap(this->priv_hasher(), other.priv_hasher());
 //These can't throw
- swap(this->priv_real_bucket_traits(), other.priv_real_bucket_traits());
+ swap(this->priv_bucket_traits(), other.priv_bucket_traits());
+ swap(this->priv_value_traits(), other.priv_value_traits());
 priv_swap_cache(cache_begin_t(), other);
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
 other.priv_size_traits().set_size(backup);
 }
- else if(incremental){
+ if(incremental){
 size_type backup = this->priv_split_traits().get_size();
 this->priv_split_traits().set_size(other.priv_split_traits().get_size());
 other.priv_split_traits().set_size(backup);
@@ -1681,7 +1723,8 @@
 //! Throws: If the internal hash function throws.
 const_iterator iterator_to(const_reference value) const
 {
- return const_iterator(bucket_type::s_iterator_to(priv_value_to_node(const_cast<reference>(value))), this);
+ siterator sit = bucket_type::s_iterator_to(const_cast<node &>(this->priv_value_to_node(value)));
+ return const_iterator(sit, this);
 }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
@@ -2151,7 +2194,7 @@
 {
 const std::size_t *primes = &detail::prime_list_holder<0>::prime_list[0];
 const std::size_t *primes_end = primes + detail::prime_list_holder<0>::prime_list_size;
- size_type const* bound = std::lower_bound(primes, primes_end, n);
+ std::size_t const* bound = std::lower_bound(primes, primes_end, n);
 if(bound == primes_end)
 --bound;
 return size_type(*bound);
@@ -2203,6 +2246,12 @@
 key_equal &priv_equal()
 { return static_cast<key_equal&>(this->data_.internal_.bucket_hash_equal_.get()); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 value_type &priv_value_from_slist_node(slist_node_ptr n)
 { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); }

@@ -2227,6 +2276,12 @@
 real_bucket_traits &priv_real_bucket_traits()
 { return this->priv_real_bucket_traits(detail::bool_<external_bucket_traits>()); }

+ const bucket_traits &priv_bucket_traits() const
+ { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; }
+
+ bucket_traits &priv_bucket_traits()
+ { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; }
+
 const hasher &priv_hasher() const
 { return static_cast<const hasher&>(this->data_.internal_.bucket_hash_equal_.bucket_hash.get()); }

@@ -2327,8 +2382,10 @@

 static node_ptr dcast_bucket_ptr(typename slist_impl::node_ptr p)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<node>(p);
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<node>(p);
+ return node_ptr(&static_cast<node&>(*p));
 }

 std::size_t priv_stored_or_compute_hash(const value_type &v, detail::true_) const
@@ -2896,7 +2953,6 @@
 //Real value traits must be calculated from options
 typedef typename detail::get_value_traits
 <T, typename packed_options::value_traits>::type value_traits;
- /// @cond
 static const bool external_value_traits =
 detail::external_value_traits_is_true<value_traits>::value;
 typedef typename detail::eval_if_c
@@ -2905,7 +2961,6 @@
 , detail::identity<value_traits>
>::type real_value_traits;
 typedef typename packed_options::bucket_traits specified_bucket_traits;
- /// @endcond

 //Real bucket traits must be calculated from options and calculated value_traits
 typedef typename detail::get_slist_impl
@@ -2991,6 +3046,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(hashtable)

 public:
 typedef typename Base::value_traits value_traits;
@@ -3012,6 +3068,13 @@
 , const value_traits &v_traits = value_traits())
 : Base(b_traits, hash_func, equal_func, v_traits)
 {}
+
+ hashtable(BOOST_RV_REF(hashtable) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ hashtable& operator=(BOOST_RV_REF(hashtable) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
};

#endif

Modified: sandbox/move/boost/intrusive/intrusive_fwd.hpp
==============================================================================
--- sandbox/move/boost/intrusive/intrusive_fwd.hpp (original)
+++ sandbox/move/boost/intrusive/intrusive_fwd.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -50,7 +50,7 @@
////////////////////////////

//slist
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -64,7 +64,7 @@
#endif
class slist;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -75,7 +75,7 @@
#endif
class slist_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -87,7 +87,7 @@
class slist_member_hook;

//list
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -99,7 +99,7 @@
#endif
class list;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -110,7 +110,7 @@
#endif
class list_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -121,8 +121,19 @@
#endif
class list_member_hook;

+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
+template
+ < class O1 = none
+ , class O2 = none
+ , class O3 = none
+ >
+#else
+template<class ...Options>
+#endif
+class list_hook;
+
//rbtree/set/multiset
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -135,7 +146,7 @@
#endif
class rbtree;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -148,7 +159,7 @@
#endif
class set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -161,7 +172,7 @@
#endif
class multiset;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -173,7 +184,7 @@
#endif
class set_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -186,7 +197,7 @@
class set_member_hook;

//splaytree/splay_set/splay_multiset
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -199,7 +210,7 @@
#endif
class splaytree;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -212,7 +223,7 @@
#endif
class splay_set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -225,7 +236,7 @@
#endif
class splay_multiset;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -236,7 +247,7 @@
#endif
class splay_set_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -248,7 +259,7 @@
class splay_set_member_hook;

//avltree/avl_set/avl_multiset
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -261,7 +272,7 @@
#endif
class avltree;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -274,7 +285,7 @@
#endif
class avl_set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -287,7 +298,7 @@
#endif
class avl_multiset;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -299,7 +310,7 @@
#endif
class avl_set_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -313,7 +324,7 @@

//treap/treap_set/treap_multiset
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -326,7 +337,7 @@
#endif
class treap;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -339,7 +350,7 @@
#endif
class treap_set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -357,7 +368,7 @@
struct priority_compare;

//sgtree/sg_set/sg_multiset
-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -370,7 +381,7 @@
#endif
class sgtree;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -383,7 +394,7 @@
#endif
class sg_set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -396,7 +407,7 @@
#endif
class sg_multiset;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -407,7 +418,7 @@
#endif
class bs_set_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -420,7 +431,7 @@

//hashtable/unordered_set/unordered_multiset

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -439,7 +450,7 @@
#endif
class hashtable;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -458,7 +469,7 @@
#endif
class unordered_set;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class T
 , class O1 = none
@@ -477,7 +488,7 @@
#endif
class unordered_multiset;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -489,7 +500,7 @@
#endif
class unordered_set_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -501,7 +512,7 @@
#endif
class unordered_set_member_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none
@@ -512,7 +523,7 @@
#endif
class any_base_hook;

-#ifndef BOOST_INTRUSIVE_VARIADIC_TEMPLATES
+#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
template
 < class O1 = none
 , class O2 = none

Modified: sandbox/move/boost/intrusive/list.hpp
==============================================================================
--- sandbox/move/boost/intrusive/list.hpp (original)
+++ sandbox/move/boost/intrusive/list.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -30,7 +30,7 @@
#include <algorithm>
#include <functional>
#include <cstddef>
-//iG pending #include <boost/pointer_cast.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -114,9 +114,8 @@
 private:
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

- //Non-copyable and non-moveable
- list_impl (const list_impl&);
- list_impl &operator =(const list_impl&);
+ //noncopyable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(list_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -173,10 +172,10 @@
 real_value_traits &get_real_value_traits(detail::bool_<true>)
 { return data_.get_value_traits(*this); }

- const value_traits &get_value_traits() const
+ const value_traits &priv_value_traits() const
 { return data_; }

- value_traits &get_value_traits()
+ value_traits &priv_value_traits()
 { return data_; }

 protected:
@@ -229,6 +228,21 @@
 this->insert(this->cend(), b, e);
 }

+ //! Effects: to-do
+ //!
+ list_impl(BOOST_RV_REF(list_impl) x)
+ : data_(::boost::move(x.priv_value_traits()))
+ {
+ this->priv_size_traits().set_size(size_type(0));
+ node_algorithms::init_header(this->get_root_node());
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ list_impl& operator=(BOOST_RV_REF(list_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: If it's not a safe-mode or an auto-unlink value_type
 //! the destructor does nothing
 //! (ie. no code is generated). Otherwise it detaches all elements from this.
@@ -988,8 +1002,8 @@
 {
 if(node_traits::get_next(this->get_root_node())
 != node_traits::get_previous(this->get_root_node())){
- list_impl carry(this->get_value_traits());
- detail::array_initializer<list_impl, 64> counter(this->get_value_traits());
+ list_impl carry(this->priv_value_traits());
+ detail::array_initializer<list_impl, 64> counter(this->priv_value_traits());
 int fill = 0;
 while(!this->empty()){
 carry.splice(carry.cbegin(), *this, this->cbegin());
@@ -1473,6 +1487,8 @@
 typedef typename Base::real_value_traits real_value_traits;
 //Assert if passed value traits are compatible with the type
 BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value));
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(list)
+
 public:
 typedef typename Base::value_traits value_traits;
 typedef typename Base::iterator iterator;
@@ -1487,6 +1503,13 @@
 : Base(b, e, v_traits)
 {}

+ list(BOOST_RV_REF(list) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ list& operator=(BOOST_RV_REF(list) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static list &container_from_end_iterator(iterator end_iterator)
 { return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/options.hpp
==============================================================================
--- sandbox/move/boost/intrusive/options.hpp (original)
+++ sandbox/move/boost/intrusive/options.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -343,6 +343,24 @@
};

+//!This option setter specifies the function object that will
+//!be used to convert between values to be inserted in a container
+//!and the hook to be used for that purpose.
+template< typename Functor>
+struct function_hook
+{
+/// @cond
+ typedef detail::function_hook_traits
+ <Functor> function_value_traits;
+ template<class Base>
+ struct pack : Base
+ {
+ typedef function_value_traits value_traits;
+ };
+/// @endcond
+};
+
+
//!This option setter specifies that the container
//!must use the specified base hook
template<typename BaseHook>
@@ -757,7 +775,7 @@
struct do_pack<typelist<Prev, Others...> >
{
typedef typename Prev::template pack
- <typename do_pack<typelist<Others...>>::type> type;
+ <typename do_pack<typelist<Others...> >::type> type;
};

Added: sandbox/move/boost/intrusive/parent_from_member.hpp
==============================================================================
--- (empty file)
+++ sandbox/move/boost/intrusive/parent_from_member.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -0,0 +1,42 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2010-2010
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP
+#define BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/parent_from_member.hpp>
+
+namespace boost {
+namespace intrusive {
+
+//! Given a pointer to a member and its corresponding pointer to data member,
+//! this function returns the pointer of the parent containing that member.
+//! Note: this function does not work with pointer to members that rely on
+//! virtual inheritance.
+template<class Parent, class Member>
+inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member)
+{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }
+
+//! Given a const pointer to a member and its corresponding const pointer to data member,
+//! this function returns the const pointer of the parent containing that member.
+//! Note: this function does not work with pointer to members that rely on
+//! virtual inheritance.
+template<class Parent, class Member>
+inline const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
+{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }
+
+} //namespace intrusive {
+} //namespace boost {
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP

Modified: sandbox/move/boost/intrusive/rbtree.hpp
==============================================================================
--- sandbox/move/boost/intrusive/rbtree.hpp (original)
+++ sandbox/move/boost/intrusive/rbtree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -33,7 +33,7 @@
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/rbtree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
-//iG pending #include <boost/pointer_cast.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -122,8 +122,7 @@
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

 //noncopyable
- rbtree_impl (const rbtree_impl&);
- rbtree_impl operator =(const rbtree_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -158,6 +157,12 @@
 value_compare &priv_comp()
 { return data_.node_plus_pred_.get(); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 const node &priv_header() const
 { return data_.node_plus_pred_.header_plus_size_.header_; }

@@ -254,6 +259,21 @@
 this->insert_equal(b, e);
 }

+ //! Effects: to-do
+ //!
+ rbtree_impl(BOOST_RV_REF(rbtree_impl) x)
+ : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
+ {
+ node_algorithms::init_header(&priv_header());
+ this->priv_size_traits().set_size(size_type(0));
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ rbtree_impl& operator=(BOOST_RV_REF(rbtree_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called), but the nodes according to
 //! the value_traits template parameter are reinitialized and thus can be reused.
@@ -478,9 +498,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal_upper_bound
+ iterator ret(node_algorithms::insert_equal_upper_bound
 (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and "hint" must be
@@ -504,9 +525,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal
+ iterator ret(node_algorithms::insert_equal
 (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: Dereferencing iterator must yield an lvalue
@@ -711,9 +733,9 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::insert_unique_commit
 (node_ptr(&priv_header()), to_insert, commit_data);
+ this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }

@@ -1284,6 +1306,8 @@
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
 , node_ptr(&priv_header())
 , get_real_value_traits().to_node_ptr(with_this));
+ if(safemode_or_autounlink)
+ node_algorithms::init(replace_this.pointed_node());
 }

 //! Requires: value must be an lvalue and shall be in a set of
@@ -1609,6 +1633,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1632,6 +1657,13 @@
 : Base(unique, b, e, cmp, v_traits)
 {}

+ rbtree(BOOST_RV_REF(rbtree) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ rbtree& operator=(BOOST_RV_REF(rbtree) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static rbtree &container_from_end_iterator(iterator end_iterator)
 { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/rbtree_algorithms.hpp
==============================================================================
--- sandbox/move/boost/intrusive/rbtree_algorithms.hpp (original)
+++ sandbox/move/boost/intrusive/rbtree_algorithms.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -57,7 +57,6 @@
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>

-
namespace boost {
namespace intrusive {

Modified: sandbox/move/boost/intrusive/set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/set.hpp (original)
+++ sandbox/move/boost/intrusive/set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -18,6 +18,7 @@
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/rbtree.hpp>
#include <iterator>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -42,13 +43,7 @@
{
 /// @cond
 typedef rbtree_impl<Config> tree_type;
- //! This class is
- //! non-copyable
- set_impl (const set_impl&);
-
- //! This class is
- //! non-assignable
- set_impl &operator =(const set_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(set_impl)

 typedef tree_type implementation_defined;
 /// @endcond
@@ -122,6 +117,17 @@
 : tree_(true, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ set_impl(BOOST_RV_REF(set_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ set_impl& operator=(BOOST_RV_REF(set_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1190,6 +1196,7 @@
 #endif
>::type Base;

+ BOOST_MOVABLE_BUT_NOT_COPYABLE(set)
 public:
 typedef typename Base::value_compare value_compare;
 typedef typename Base::value_traits value_traits;
@@ -1211,6 +1218,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ set(BOOST_RV_REF(set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ set& operator=(BOOST_RV_REF(set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static set &container_from_end_iterator(iterator end_iterator)
 { return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); }

@@ -1247,9 +1261,7 @@
 /// @cond
 typedef rbtree_impl<Config> tree_type;

- //Non-copyable and non-assignable
- multiset_impl (const multiset_impl&);
- multiset_impl &operator =(const multiset_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset_impl)
 typedef tree_type implementation_defined;
 /// @endcond

@@ -1321,6 +1333,17 @@
 : tree_(false, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ multiset_impl(BOOST_RV_REF(multiset_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ multiset_impl& operator=(BOOST_RV_REF(multiset_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2307,6 +2330,8 @@
 Options...
 #endif
>::type Base;
+
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset)

 public:
 typedef typename Base::value_compare value_compare;
@@ -2329,6 +2354,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ multiset(BOOST_RV_REF(multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ multiset& operator=(BOOST_RV_REF(multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static multiset &container_from_end_iterator(iterator end_iterator)
 { return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/sg_set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/sg_set.hpp (original)
+++ sandbox/move/boost/intrusive/sg_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/sgtree.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/move/move.hpp>
#include <iterator>

namespace boost {
@@ -42,12 +43,8 @@
 /// @cond
 typedef sgtree_impl<Config> tree_type;
 //! This class is
- //! non-copyable
- sg_set_impl (const sg_set_impl&);
-
- //! This class is
- //! non-assignable
- sg_set_impl &operator =(const sg_set_impl&);
+ //! movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set_impl)

 typedef tree_type implementation_defined;
 /// @endcond
@@ -111,6 +108,17 @@
 : tree_(true, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ sg_set_impl(BOOST_RV_REF(sg_set_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ sg_set_impl& operator=(BOOST_RV_REF(sg_set_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the sg_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1218,6 +1226,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1240,6 +1249,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ sg_set(BOOST_RV_REF(sg_set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ sg_set& operator=(BOOST_RV_REF(sg_set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static sg_set &container_from_end_iterator(iterator end_iterator)
 { return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator)); }

@@ -1277,8 +1293,7 @@
 typedef sgtree_impl<Config> tree_type;

 //Non-copyable and non-assignable
- sg_multiset_impl (const sg_multiset_impl&);
- sg_multiset_impl &operator =(const sg_multiset_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset_impl)
 typedef tree_type implementation_defined;
 /// @endcond

@@ -1341,6 +1356,17 @@
 : tree_(false, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ sg_multiset_impl(BOOST_RV_REF(sg_multiset_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ sg_multiset_impl& operator=(BOOST_RV_REF(sg_multiset_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the sg_multiset
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2352,6 +2378,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset)

 public:
 typedef typename Base::value_compare value_compare;
@@ -2374,6 +2401,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ sg_multiset(BOOST_RV_REF(sg_multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static sg_multiset &container_from_end_iterator(iterator end_iterator)
 { return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/sgtree.hpp
==============================================================================
--- sandbox/move/boost/intrusive/sgtree.hpp (original)
+++ sandbox/move/boost/intrusive/sgtree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -38,6 +38,7 @@
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/sgtree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -254,8 +255,7 @@
 typedef typename alpha_traits::multiply_by_alpha_t multiply_by_alpha_t;

 //noncopyable
- sgtree_impl (const sgtree_impl&);
- sgtree_impl operator =(const sgtree_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -303,6 +303,12 @@
 value_compare &priv_comp()
 { return data_.node_plus_pred_.get(); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 const node &priv_header() const
 { return data_.node_plus_pred_.header_plus_alpha_.header_; }

@@ -395,6 +401,21 @@
 this->insert_equal(b, e);
 }

+ //! Effects: to-do
+ //!
+ sgtree_impl(BOOST_RV_REF(sgtree_impl) x)
+ : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
+ {
+ node_algorithms::init_header(&priv_header());
+ this->priv_size_traits().set_size(size_type(0));
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ sgtree_impl& operator=(BOOST_RV_REF(sgtree_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called), but the nodes according to
 //! the value_traits template parameter are reinitialized and thus can be reused.
@@ -621,11 +642,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_equal_upper_bound
 (node_ptr(&priv_header()), to_insert, key_node_comp
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 return iterator(p, this);
 }
@@ -651,11 +672,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_equal
 (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp
 , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 return iterator(p, this);
 }
@@ -862,11 +883,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::insert_unique_commit
 ( node_ptr(&priv_header()), to_insert, commit_data
 , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 return iterator(to_insert, this);
 }
@@ -890,11 +911,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_before
 ( node_ptr(&priv_header()), pos.pointed_node(), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 return iterator(p, this);
 }
@@ -918,11 +939,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::push_back
 ( node_ptr(&priv_header()), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 }

@@ -945,11 +966,11 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::push_front
 ( node_ptr(&priv_header()), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
+ this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
 }

@@ -1453,6 +1474,8 @@
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
 , node_ptr(&priv_header())
 , get_real_value_traits().to_node_ptr(with_this));
+ if(safemode_or_autounlink)
+ node_algorithms::init(replace_this.pointed_node());
 }

 //! Requires: value must be an lvalue and shall be in a set of
@@ -1836,6 +1859,8 @@
 #endif
>::type Base;

+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree)
+
 public:
 typedef typename Base::value_compare value_compare;
 typedef typename Base::value_traits value_traits;
@@ -1858,6 +1883,13 @@
 : Base(unique, b, e, cmp, v_traits)
 {}

+ sgtree(BOOST_RV_REF(sgtree) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ sgtree& operator=(BOOST_RV_REF(sgtree) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static sgtree &container_from_end_iterator(iterator end_iterator)
 { return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/slist.hpp
==============================================================================
--- sandbox/move/boost/intrusive/slist.hpp (original)
+++ sandbox/move/boost/intrusive/slist.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -31,7 +31,7 @@
#include <algorithm>
#include <cstddef> //std::size_t
#include <utility> //std::pair
-//iG pending #include <boost/pointer_cast.hpp>
+#include <boost/move/move.hpp>

namespace boost {
namespace intrusive {
@@ -148,13 +148,8 @@
 private:
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

- //! This class is
- //! non-copyable
- slist_impl (const slist_impl&);
-
- //! This class is
- //! non-asignable
- slist_impl &operator =(const slist_impl&);
+ //noncopyable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(slist_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -252,10 +247,10 @@
 real_value_traits &get_real_value_traits(detail::bool_<true>)
 { return data_.get_value_traits(*this); }

- const value_traits &get_value_traits() const
+ const value_traits &priv_value_traits() const
 { return data_; }

- value_traits &get_value_traits()
+ value_traits &priv_value_traits()
 { return data_; }

 protected:
@@ -305,6 +300,21 @@
 this->insert_after(this->cbefore_begin(), b, e);
 }

+ //! Effects: to-do
+ //!
+ slist_impl(BOOST_RV_REF(slist_impl) x)
+ : data_(::boost::move(x.priv_value_traits()))
+ {
+ this->priv_size_traits().set_size(size_type(0));
+ node_algorithms::init_header(this->get_root_node());
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ slist_impl& operator=(BOOST_RV_REF(slist_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: If it's a safe-mode
 //! or auto-unlink value, the destructor does nothing
 //! (ie. no code is generated). Otherwise it detaches all elements from this.
@@ -1313,8 +1323,8 @@
 if (node_traits::get_next(node_traits::get_next(this->get_root_node()))
 != this->get_root_node()) {

- slist_impl carry(this->get_value_traits());
- detail::array_initializer<slist_impl, 64> counter(this->get_value_traits());
+ slist_impl carry(this->priv_value_traits());
+ detail::array_initializer<slist_impl, 64> counter(this->priv_value_traits());
 int fill = 0;
 const_iterator last_inserted;
 while(!this->empty()){
@@ -2084,6 +2094,8 @@
 typedef typename Base::real_value_traits real_value_traits;
 //Assert if passed value traits are compatible with the type
 BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value));
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(slist)
+
 public:
 typedef typename Base::value_traits value_traits;
 typedef typename Base::iterator iterator;
@@ -2098,6 +2110,13 @@
 : Base(b, e, v_traits)
 {}

+ slist(BOOST_RV_REF(slist) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ slist& operator=(BOOST_RV_REF(slist) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static slist &container_from_end_iterator(iterator end_iterator)
 { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/splay_set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/splay_set.hpp (original)
+++ sandbox/move/boost/intrusive/splay_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/splaytree.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/move/move.hpp>
#include <iterator>

namespace boost {
@@ -42,12 +43,8 @@
 /// @cond
 typedef splaytree_impl<Config> tree_type;
 //! This class is
- //! non-copyable
- splay_set_impl (const splay_set_impl&);
-
- //! This class is
- //! non-assignable
- splay_set_impl &operator =(const splay_set_impl&);
+ //! movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set_impl)

 typedef tree_type implementation_defined;
 /// @endcond
@@ -113,6 +110,17 @@
 : tree_(true, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ splay_set_impl(BOOST_RV_REF(splay_set_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ splay_set_impl& operator=(BOOST_RV_REF(splay_set_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the splay_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1202,6 +1210,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1224,6 +1233,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ splay_set(BOOST_RV_REF(splay_set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ splay_set& operator=(BOOST_RV_REF(splay_set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static splay_set &container_from_end_iterator(iterator end_iterator)
 { return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); }

@@ -1260,9 +1276,8 @@
 /// @cond
 typedef splaytree_impl<Config> tree_type;

- //Non-copyable and non-assignable
- splay_multiset_impl (const splay_multiset_impl&);
- splay_multiset_impl &operator =(const splay_multiset_impl&);
+ //Movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset_impl)
 typedef tree_type implementation_defined;
 /// @endcond

@@ -1327,6 +1342,17 @@
 : tree_(false, b, e, cmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ splay_multiset_impl(BOOST_RV_REF(splay_multiset_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ splay_multiset_impl& operator=(BOOST_RV_REF(splay_multiset_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2324,6 +2350,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset)

 public:
 typedef typename Base::value_compare value_compare;
@@ -2346,6 +2373,13 @@
 : Base(b, e, cmp, v_traits)
 {}

+ splay_multiset(BOOST_RV_REF(splay_multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static splay_multiset &container_from_end_iterator(iterator end_iterator)
 { return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/splaytree.hpp
==============================================================================
--- sandbox/move/boost/intrusive/splaytree.hpp (original)
+++ sandbox/move/boost/intrusive/splaytree.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -30,6 +30,7 @@
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/splaytree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
+#include <boost/move/move.hpp>

namespace boost {
@@ -122,8 +123,7 @@
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

 //noncopyable
- splaytree_impl (const splaytree_impl&);
- splaytree_impl operator =(const splaytree_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -158,6 +158,12 @@
 value_compare &priv_comp()
 { return data_.node_plus_pred_.get(); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 const node &priv_header() const
 { return data_.node_plus_pred_.header_plus_size_.header_; }

@@ -240,6 +246,21 @@
 this->insert_equal(b, e);
 }

+ //! Effects: to-do
+ //!
+ splaytree_impl(BOOST_RV_REF(splaytree_impl) x)
+ : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
+ {
+ node_algorithms::init_header(&priv_header());
+ this->priv_size_traits().set_size(size_type(0));
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ splaytree_impl& operator=(BOOST_RV_REF(splaytree_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called), but the nodes according to
 //! the value_traits template parameter are reinitialized and thus can be reused.
@@ -466,9 +487,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal_lower_bound
+ iterator ret (node_algorithms::insert_equal_lower_bound
 (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and "hint" must be
@@ -492,9 +514,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal
+ iterator ret(node_algorithms::insert_equal
 (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: Dereferencing iterator must yield an lvalue
@@ -693,9 +716,9 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::insert_unique_commit
 (node_ptr(&priv_header()), to_insert, commit_data);
+ this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }

@@ -1259,6 +1282,8 @@
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
 , node_ptr(&priv_header())
 , get_real_value_traits().to_node_ptr(with_this));
+ if(safemode_or_autounlink)
+ node_algorithms::init(replace_this.pointed_node());
 }

 //! Requires: value must be an lvalue and shall be in a set of
@@ -1610,6 +1635,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1633,6 +1659,13 @@
 : Base(unique, b, e, cmp, v_traits)
 {}

+ splaytree(BOOST_RV_REF(splaytree) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ splaytree& operator=(BOOST_RV_REF(splaytree) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static splaytree &container_from_end_iterator(iterator end_iterator)
 { return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/treap.hpp
==============================================================================
--- sandbox/move/boost/intrusive/treap.hpp (original)
+++ sandbox/move/boost/intrusive/treap.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -31,6 +31,7 @@
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/treap_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
+#include <boost/move/move.hpp>
#include <boost/intrusive/priority_compare.hpp>

namespace boost {
@@ -126,8 +127,7 @@
 typedef detail::size_holder<constant_time_size, size_type> size_traits;

 //noncopyable
- treap_impl (const treap_impl&);
- treap_impl operator =(const treap_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_impl)

 enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
@@ -176,6 +176,12 @@
 priority_compare &priv_pcomp()
 { return data_.node_plus_pred_.header_plus_priority_size_.get(); }

+ const value_traits &priv_value_traits() const
+ { return data_; }
+
+ value_traits &priv_value_traits()
+ { return data_; }
+
 const node &priv_header() const
 { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_; }

@@ -224,7 +230,7 @@
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor of the value_compare/priority_compare objects throw. Basic guarantee.
- treap_impl( const value_compare &cmp = value_compare()
+ treap_impl( const value_compare &cmp = value_compare()
 , const priority_compare &pcmp = priority_compare()
 , const value_traits &v_traits = value_traits())
 : data_(cmp, pcmp, v_traits)
@@ -261,6 +267,23 @@
 this->insert_equal(b, e);
 }

+ //! Effects: to-do
+ //!
+ treap_impl(BOOST_RV_REF(treap_impl) x)
+ : data_( ::boost::move(x.priv_comp())
+ , ::boost::move(x.priv_pcomp())
+ , ::boost::move(x.priv_value_traits()))
+ {
+ node_algorithms::init_header(&priv_header());
+ this->priv_size_traits().set_size(size_type(0));
+ this->swap(x);
+ }
+
+ //! Effects: to-do
+ //!
+ treap_impl& operator=(BOOST_RV_REF(treap_impl) x)
+ { this->swap(x); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called), but the nodes according to
 //! the value_traits template parameter are reinitialized and thus can be reused.
@@ -549,9 +572,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal_upper_bound
+ iterator ret(node_algorithms::insert_equal_upper_bound
 (node_ptr(&priv_header()), to_insert, key_node_comp, key_node_pcomp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and "hint" must be
@@ -577,9 +601,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
- return iterator(node_algorithms::insert_equal
+ iterator ret (node_algorithms::insert_equal
 (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp, key_node_pcomp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: Dereferencing iterator must yield an lvalue
@@ -801,8 +826,8 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 node_algorithms::insert_unique_commit(node_ptr(&priv_header()), to_insert, commit_data);
+ this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }

@@ -825,11 +850,12 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
- return iterator(node_algorithms::insert_before
+ iterator ret (node_algorithms::insert_before
 (node_ptr(&priv_header()), pos.pointed_node(), to_insert, pcomp), this);
+ this->priv_size_traits().increment();
+ return ret;
 }

 //! Requires: value must be an lvalue, and it must be no less
@@ -851,10 +877,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
 node_algorithms::push_back(node_ptr(&priv_header()), to_insert, pcomp);
+ this->priv_size_traits().increment();
 }

 //! Requires: value must be an lvalue, and it must be no greater
@@ -876,10 +902,10 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- this->priv_size_traits().increment();
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
 node_algorithms::push_front(node_ptr(&priv_header()), to_insert, pcomp);
+ this->priv_size_traits().increment();
 }

 //! Effects: Erases the element pointed to by pos.
@@ -1384,6 +1410,8 @@
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
 , node_ptr(&priv_header())
 , get_real_value_traits().to_node_ptr(with_this));
+ if(safemode_or_autounlink)
+ node_algorithms::init(replace_this.pointed_node());
 }

 //! Requires: value must be an lvalue and shall be in a set of
@@ -1696,6 +1724,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1722,6 +1751,13 @@
 : Base(unique, b, e, cmp, pcmp, v_traits)
 {}

+ treap(BOOST_RV_REF(treap) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ treap& operator=(BOOST_RV_REF(treap) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static treap &container_from_end_iterator(iterator end_iterator)
 { return static_cast<treap &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/treap_set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/treap_set.hpp (original)
+++ sandbox/move/boost/intrusive/treap_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,6 +16,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/treap.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/move/move.hpp>
#include <iterator>

namespace boost {
@@ -42,12 +43,8 @@
 /// @cond
 typedef treap_impl<Config> tree_type;
 //! This class is
- //! non-copyable
- treap_set_impl (const treap_set_impl&);
-
- //! This class is
- //! non-assignable
- treap_set_impl &operator =(const treap_set_impl&);
+ //! movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set_impl)

 typedef tree_type implementation_defined;
 /// @endcond
@@ -116,6 +113,17 @@
 : tree_(true, b, e, cmp, pcmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ treap_set_impl(BOOST_RV_REF(treap_set_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ treap_set_impl& operator=(BOOST_RV_REF(treap_set_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the treap_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1294,6 +1302,7 @@
 Options...
 #endif
>::type Base;
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set)

 public:
 typedef typename Base::value_compare value_compare;
@@ -1319,6 +1328,13 @@
 : Base(b, e, cmp, pcmp, v_traits)
 {}

+ treap_set(BOOST_RV_REF(treap_set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ treap_set& operator=(BOOST_RV_REF(treap_set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static treap_set &container_from_end_iterator(iterator end_iterator)
 { return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator)); }

@@ -1355,9 +1371,7 @@
 /// @cond
 typedef treap_impl<Config> tree_type;

- //Non-copyable and non-assignable
- treap_multiset_impl (const treap_multiset_impl&);
- treap_multiset_impl &operator =(const treap_multiset_impl&);
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset_impl)
 typedef tree_type implementation_defined;
 /// @endcond

@@ -1425,6 +1439,17 @@
 : tree_(false, b, e, cmp, pcmp, v_traits)
 {}

+ //! Effects: to-do
+ //!
+ treap_multiset_impl(BOOST_RV_REF(treap_multiset_impl) x)
+ : tree_(::boost::move(x.tree_))
+ {}
+
+ //! Effects: to-do
+ //!
+ treap_multiset_impl& operator=(BOOST_RV_REF(treap_multiset_impl) x)
+ { tree_ = ::boost::move(x.tree_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the treap_multiset
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2499,6 +2524,8 @@
 Options...
 #endif
>::type Base;
+ //Movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset)

 public:
 typedef typename Base::value_compare value_compare;
@@ -2524,6 +2551,13 @@
 : Base(b, e, cmp, pcmp, v_traits)
 {}

+ treap_multiset(BOOST_RV_REF(treap_multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
+
 static treap_multiset &container_from_end_iterator(iterator end_iterator)
 { return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator)); }

Modified: sandbox/move/boost/intrusive/unordered_set.hpp
==============================================================================
--- sandbox/move/boost/intrusive/unordered_set.hpp (original)
+++ sandbox/move/boost/intrusive/unordered_set.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -16,8 +16,10 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/hashtable.hpp>
+#include <boost/move/move.hpp>
#include <iterator>

+
namespace boost {
namespace intrusive {

@@ -39,7 +41,7 @@
//! The container supports the following options:
//! \c base_hook<>/member_hook<>/value_traits<>,
//! \c constant_time_size<>, \c size_type<>, \c hash<> and \c equal<>
-//! \c bucket_traits<>, power_2_buckets<> and cache_begin<>.
+//! \c bucket_traits<>, \c power_2_buckets<> and \c cache_begin<>.
//!
//! unordered_set only provides forward iterators but it provides 4 iterator types:
//! iterator and const_iterator to navigate through the whole container and
@@ -68,12 +70,8 @@
 typedef hashtable_impl<Config> table_type;

 //! This class is
- //! non-copyable
- unordered_set_impl (const unordered_set_impl&);
-
- //! This class is
- //! non-assignable
- unordered_set_impl &operator =(const unordered_set_impl&);
+ //! movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_set_impl)

 typedef table_type implementation_defined;
 /// @endcond
@@ -156,6 +154,17 @@
 : table_(b_traits, hash_func, equal_func, v_traits)
 { table_.insert_unique(b, e); }

+ //! Effects: to-do
+ //!
+ unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
+ : table_(::boost::move(x.table_))
+ {}
+
+ //! Effects: to-do
+ //!
+ unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
+ { table_ = ::boost::move(x.table_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the unordered_set
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -1046,6 +1055,7 @@

 //Assert if passed value traits are compatible with the type
 BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_set)

 public:
 typedef typename Base::value_traits value_traits;
@@ -1073,6 +1083,13 @@
 , const value_traits &v_traits = value_traits())
 : Base(b, e, b_traits, hash_func, equal_func, v_traits)
 {}
+
+ unordered_set(BOOST_RV_REF(unordered_set) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
};

#endif
@@ -1096,7 +1113,7 @@
//! The container supports the following options:
//! \c base_hook<>/member_hook<>/value_traits<>,
//! \c constant_time_size<>, \c size_type<>, \c hash<> and \c equal<>
-//! \c bucket_traits<>, power_2_buckets<> and cache_begin<>.
+//! \c bucket_traits<>, \c power_2_buckets<> and \c cache_begin<>.
//!
//! unordered_multiset only provides forward iterators but it provides 4 iterator types:
//! iterator and const_iterator to navigate through the whole container and
@@ -1125,13 +1142,8 @@
 typedef hashtable_impl<Config> table_type;
 /// @endcond

- //! This class is
- //! non-copyable
- unordered_multiset_impl (const unordered_multiset_impl&);
-
- //! This class is
- //! non-assignable
- unordered_multiset_impl &operator =(const unordered_multiset_impl&);
+ //Movable
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_multiset_impl)

 typedef table_type implementation_defined;

@@ -1213,6 +1225,17 @@
 : table_(b_traits, hash_func, equal_func, v_traits)
 { table_.insert_equal(b, e); }

+ //! Effects: to-do
+ //!
+ unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
+ : table_(::boost::move(x.table_))
+ {}
+
+ //! Effects: to-do
+ //!
+ unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
+ { table_ = ::boost::move(x.table_); return *this; }
+
 //! Effects: Detaches all elements from this. The objects in the unordered_multiset
 //! are not deleted (i.e. no destructors are called).
 //!
@@ -2045,6 +2068,7 @@
>::type Base;
 //Assert if passed value traits are compatible with the type
 BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_multiset)

 public:
 typedef typename Base::value_traits value_traits;
@@ -2072,6 +2096,13 @@
 , const value_traits &v_traits = value_traits())
 : Base(b, e, b_traits, hash_func, equal_func, v_traits)
 {}
+
+ unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
+ : Base(::boost::move(static_cast<Base&>(x)))
+ {}
+
+ unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+ { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }
};

#endif

Modified: sandbox/move/boost/intrusive/unordered_set_hook.hpp
==============================================================================
--- sandbox/move/boost/intrusive/unordered_set_hook.hpp (original)
+++ sandbox/move/boost/intrusive/unordered_set_hook.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -78,8 +78,10 @@

 static node_ptr get_next(const_node_ptr n)
 {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<node>(n->next_);
+// This still fails in gcc < 4.4 so forget about it
+// using ::boost::static_pointer_cast;
+// return static_pointer_cast<node>(n->next_);
+ return node_ptr(&static_cast<node&>(*n->next_));
 }

 static void set_next(node_ptr n, node_ptr next)

Modified: sandbox/move/boost/move/move.hpp
==============================================================================
--- sandbox/move/boost/move/move.hpp (original)
+++ sandbox/move/boost/move/move.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -1,6 +1,7 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright David Abrahams, Vicente Botet, Ion Gaztanaga 2009.
+// (C) Copyright David Abrahams, Vicente Botet 2009.
+// (C) Copyright Ion Gaztanaga 2009-2010.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -8,77 +9,100 @@
// See http://www.boost.org/libs/move for documentation.
//
//////////////////////////////////////////////////////////////////////////////
-//
-// Parts of this file come from Adobe's Move library:
-//
-// Copyright 2005-2007 Adobe Systems Incorporated
-// Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
-// or a copy at http://stlab.adobe.com/licenses.html)
-//
-//////////////////////////////////////////////////////////////////////////////

//! \file

-#ifndef BOOST_MOVE_DETAIL_MOVE_HPP
-#define BOOST_MOVE_DETAIL_MOVE_HPP
+#ifndef BOOST_MOVE_MOVE_HPP
+#define BOOST_MOVE_MOVE_HPP

#include <boost/config.hpp>
#include <algorithm> //copy, copy_backward
#include <memory> //uninitialized_copy
#include <iterator> //std::iterator
-#include <boost/mpl/if.hpp>
+
+#define BOOST_MOVE_AVOID_BOOST_DEPENDENCIES
+
+#ifndef BOOST_MOVE_AVOID_BOOST_DEPENDENCIES
#include <boost/utility/enable_if.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#endif //#ifdef BOOST_MOVE_AVOID_BOOST_DEPENDENCIES
+/// @cond
+
+#ifdef BOOST_MOVE_AVOID_BOOST_DEPENDENCIES
+#define BOOST_MOVE_MPL_NS ::boost::move_detail
+#define BOOST_MOVE_BOOST_NS ::boost::move_detail
+#else
+#define BOOST_MOVE_MPL_NS ::boost::mpl
+#define BOOST_MOVE_BOOST_NS ::boost
+#endif

-//! Defining or undefining this macro will change Boost.Move behaviour
-//! for copyable and movable classes when assigning from non-const rvalues:
-//! \code
-//! copyable_and_movable produce(){ return copyable_and_movable(); }
-//! \endcode
-//! If the macro is NOT defined:
-//! \code
-//! copyable_and_movable cm;
-//! cm = copyable_and_movable(); //object is COPIED (missed optimization)
-//! \endcode
-//! If the macro IS defined:
-//! \code
-//! copyable_and_movable cm;
-//! cm = copyable_and_movable(); //object is MOVED
-//! \endcode
-//! However, the second option has also some downsides. See documentation for more details.
-#define BOOST_MOVE_OPTIMIZED_EMULATION
+#ifdef BOOST_MOVE_AVOID_BOOST_DEPENDENCIES

-/// @cond
+namespace boost {
+namespace move_detail {

-//Define to easily port between Boost.Move and internal Boost.Interprocess move emulation
-//#define BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+//if_
+template<bool C, typename T1, typename T2>
+struct if_c
+{
+ typedef T1 type;
+};

-#ifdef BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+template<typename T1, typename T2>
+struct if_c<false,T1,T2>
+{
+ typedef T2 type;
+};

-#define INTERPROCESS_NAMESPACE_BEGIN namespace interprocess {
-#define INTERPROCESS_NAMESPACE_END }// namespace interprocess {
-#define BOOST_MOVE_NAMESPACE boost::interprocess
+template<typename T1, typename T2, typename T3>
+struct if_
+{
+ typedef typename if_c<0 != T1::value, T2, T3>::type type;
+};

-#else //BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+//enable_if_
+template <bool B, class T = void>
+struct enable_if_c
+{
+ typedef T type;
+};

-#define INTERPROCESS_NAMESPACE_BEGIN
-#define INTERPROCESS_NAMESPACE_END
-#define BOOST_MOVE_NAMESPACE boost
+template <class T>
+struct enable_if_c<false, T> {};

-#endif //BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+template <class Cond, class T = void>
+struct enable_if : public enable_if_c<Cond::value, T> {};

-namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN
-namespace move_detail {
+template <class Cond, class T = void>
+struct disable_if : public enable_if_c<!Cond::value, T> {};
+
+//integral_constant
+template<class T, T v>
+struct integral_constant
+{
+ static const T value = v;
+ typedef T value_type;
+ typedef integral_constant<T, v> type;
+};

+//identity
template <class T>
struct identity
{
 typedef T type;
};

+//is_convertible
template <class T, class U>
class is_convertible
{
@@ -91,20 +115,121 @@
 enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
};

+//and_ not_
+template <typename Condition1, typename Condition2, typename Condition3 = integral_constant<bool, true> >
+ struct and_
+ : public integral_constant<bool, Condition1::value && Condition2::value && Condition3::value>
+{};
+
+template <typename Boolean>
+ struct not_
+ : public integral_constant<bool, !Boolean::value>
+{};
+
+//is_lvalue_reference
+template<class T>
+struct is_lvalue_reference
+ : public integral_constant<bool, false>
+{};
+
+template<class T>
+struct is_lvalue_reference<T&>
+ : public integral_constant<bool, true>
+{};
+
+//has_trivial_destructor
+template<class T>
+struct has_trivial_destructor
+ : public integral_constant<bool, false>
+{};
+
+//addressof
+template<class T> struct addr_impl_ref
+{
+ T & v_;
+ inline addr_impl_ref( T & v ): v_( v ) {}
+ inline operator T& () const { return v_; }
+
+ private:
+ addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+ static inline T * f( T & v, long )
+ {
+ return reinterpret_cast<T*>(
+ &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+ }
+
+ static inline T * f( T * v, int )
+ { return v; }
+};
+
+template<class T> T * addressof( T & v )
+{
+ return ::boost::move_detail::addressof_impl<T>::f
+ ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
+}
+
+/*
+typedef char one;
+struct two {one _[2];};
+
+template <typename B, typename D>
+struct is_base_of_host
+{
+ operator B*() const;
+ operator D*();
+};
+
+template <typename B, typename D>
+struct is_base_of
+{
+ typedef char yes;
+ class no { char dummy[2]; };
+
+ template <typename T>
+ static yes check(D*, T);
+ static no check(B*, int);
+
+ static const bool value = sizeof(check(is_base_of_host<B,D>(), int())) == sizeof(yes);
+};
+*/
+
} //namespace move_detail {
-INTERPROCESS_NAMESPACE_END
} //namespace boost {

+#endif //BOOST_MOVE_AVOID_BOOST_DEPENDENCIES
+
/// @endcond

+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5)
+
+#define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+
+#else
+
+#if defined(_MSC_VER) && (_MSC_VER == 1600)
+#define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+#endif
+
+#endif
+
+#endif
+
+
#if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)

-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
+#ifdef __GNUC__
+# define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
+#else
+# define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS
+#endif

namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN

//////////////////////////////////////////////////////////////////////////////
//
@@ -118,7 +243,7 @@
 ~rv();
 rv(rv const&);
 void operator=(rv const&);
-};
+} BOOST_MOVE_ATTRIBUTE_MAY_ALIAS;

//////////////////////////////////////////////////////////////////////////////
//
@@ -130,40 +255,45 @@

template <class T>
struct is_rv
-{
- static const bool value = false;
-};
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, false>
+{};

template <class T>
struct is_rv< rv<T> >
-{
- static const bool value = true;
-};
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+{};
+
+template <class T>
+struct is_rv< const rv<T> >
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+{};

} //namespace move_detail {

//////////////////////////////////////////////////////////////////////////////
//
-// is_movable
+// has_move_emulation_enabled
//
//////////////////////////////////////////////////////////////////////////////
template<class T>
-struct is_movable
- : public ::boost::mpl::bool_<move_detail::is_convertible<T, rv<T>&>::value>
-{
-};
+struct has_move_emulation_enabled
+ : BOOST_MOVE_BOOST_NS::is_convertible< T, ::boost::rv<T>& >
+{};

template<class T>
-struct is_movable< rv<T> >
- : public ::boost::mpl::bool_<false>
-{
-};
+struct has_move_emulation_enabled<T&>
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, false>
+{};
+
+template<class T>
+struct has_move_emulation_enabled< ::boost::rv<T> >
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, false>
+{};

template <class T>
struct has_nothrow_move
- : public ::boost::mpl::bool_<false>
-{
-};
+ : public BOOST_MOVE_BOOST_NS::integral_constant<bool, false>
+{};

//////////////////////////////////////////////////////////////////////////////
//
@@ -171,34 +301,33 @@
//
//////////////////////////////////////////////////////////////////////////////
template <class T>
-typename ::boost::disable_if<is_movable<T>, T&>::type move(T& x)
+typename BOOST_MOVE_BOOST_NS::disable_if<has_move_emulation_enabled<T>, T&>::type move(T& x)
{
 return x;
}

template <class T>
-typename enable_if<is_movable<T>, rv<T>&>::type move(T& x)
+typename BOOST_MOVE_BOOST_NS::enable_if<has_move_emulation_enabled<T>, rv<T>&>::type move(T& x)
{
- return *static_cast<rv<T>* >(boost::addressof(x));
+ return *static_cast<rv<T>* >(BOOST_MOVE_BOOST_NS::addressof(x));
}

template <class T>
-typename enable_if<is_movable<T>, rv<T>&>::type move(rv<T>& x)
+typename BOOST_MOVE_BOOST_NS::enable_if<has_move_emulation_enabled<T>, rv<T>&>::type move(rv<T>& x)
{
 return x;
}

-
#define BOOST_RV_REF(TYPE)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
+ ::boost::rv< TYPE >& \
//

#define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
+ ::boost::rv< TYPE<ARG1, ARG2> >& \
//

#define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
+ ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
//

@@ -207,21 +336,19 @@
//

#define BOOST_CATCH_CONST_RLVALUE(TYPE)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
+ const ::boost::rv< TYPE >& \
//

-#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
#define BOOST_COPY_ASSIGN_REF(TYPE)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
+ const ::boost::rv< TYPE >& \
//

-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
+#define BOOST_MOVE_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ const ::boost::rv< TYPE<ARG1, ARG2> >& \
//

-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
+#define BOOST_MOVE_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ const ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
//

//////////////////////////////////////////////////////////////////////////////
@@ -231,109 +358,19 @@
//////////////////////////////////////////////////////////////////////////////

template <class T>
-typename enable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, T &>::type
- forward(const typename move_detail::identity<T>::type &x)
-{
- return const_cast<T&>(x);
-}
-
-template <class T>
-typename disable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, const T &>::type
- forward(const typename move_detail::identity<T>::type &x)
-{
- return x;
-}
-
-#else //BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPY_ASSIGN_REF(TYPE)\
- const TYPE & \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const TYPE< ARG1, ARG2 >& \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const TYPE< ARG1, ARG2, ARG3 > & \
-//
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// forward()
-//
-//////////////////////////////////////////////////////////////////////////////
-/*
-template <class T>
-typename enable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, T &>::type
- forward(const typename move_detail::identity<T>::type &x)
+typename BOOST_MOVE_BOOST_NS::enable_if< ::boost::move_detail::is_rv<T>, T &>::type
+ forward(const typename BOOST_MOVE_MPL_NS::identity<T>::type &x)
{
 return const_cast<T&>(x);
}

template <class T>
-typename disable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, const T &>::type
- forward(const typename move_detail::identity<T>::type &x)
-{
- return x;
-}
-*/
-
-//Catches const lvalues for movable types
-template <class T>
-const T&
- forward( BOOST_CATCH_CONST_RLVALUE(T) x
- , typename ::boost::enable_if_c< ::BOOST_MOVE_NAMESPACE::is_movable<T>::value >::type* = 0)
-{
- return static_cast<const T&>(x);
-}
-
-//Catches const lvalues for non-movable types
-template <class T>
-const T&
- forward( const T &x
- , typename ::boost::enable_if_c< !::BOOST_MOVE_NAMESPACE::is_movable<T>::value &&
- !::boost::move_detail::is_rv<T>::value
- >::type* = 0)
-{
- return static_cast<const T&>(x);
-}
-
-//Catches forwarded ::boost::rv<T> via BOOST_FWD_REFs
-template <class T>
-T &
- forward( const T &t
- , typename ::boost::enable_if_c< ::boost::move_detail::is_rv<T>::value >::type* = 0)
-{
- return const_cast<T&>(t);
-}
-
-//Catches forwarded ::boost::rv<T>
-template <class T, class U>
-const T &
- forward( const U &u
- , typename ::boost::enable_if_c< ::boost::is_same< ::boost::rv<T>, U >::value >::type * = 0)
-{
- return static_cast<const T&>(u);
-}
-
-//Catches non-const lvalues
-template <class T>
-T&
- forward( typename move_detail::identity<T>::type &x
- , typename ::boost::enable_if_c< !::boost::move_detail::is_rv<T>::value >::type* = 0)
+typename BOOST_MOVE_BOOST_NS::disable_if< ::boost::move_detail::is_rv<T>, const T &>::type
+ forward(const typename BOOST_MOVE_MPL_NS::identity<T>::type &x)
{
 return x;
}

-//Catches non-const rvalues
-template <class T>
-typename enable_if<is_movable<T>, ::boost::rv<T> & >::type
- forward(BOOST_RV_REF(T) x)
-{ return x; }
-
-#endif
-
//////////////////////////////////////////////////////////////////////////////
//
// BOOST_MOVABLE_BUT_NOT_COPYABLE
@@ -344,10 +381,10 @@
 TYPE(TYPE &);\
 TYPE& operator=(TYPE &);\
 public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *reinterpret_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
 private:\
//

@@ -357,35 +394,27 @@
//
//////////////////////////////////////////////////////////////////////////////

-#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
 public:\
 TYPE& operator=(TYPE &t)\
- { this->operator=(static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
+ { this->operator=(static_cast<const ::boost::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
 public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *reinterpret_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
 private:\
//

-#else //#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+#define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
 public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *reinterpret_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
 private:\
//

-#endif
-
-
-INTERPROCESS_NAMESPACE_END
} //namespace boost

#else //BOOST_NO_RVALUE_REFERENCES
@@ -393,58 +422,12 @@
#include <boost/type_traits/remove_reference.hpp>

namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN
-
-/// @cond
-
-namespace move_detail {
-
-template<class T>
-struct is_lvalue_reference
- : public ::boost::mpl::bool_<false>
-{};
-
-template<class T>
-struct is_lvalue_reference<T&>
- : public ::boost::mpl::bool_<true>
-{};
-
-typedef char one;
-struct two {one _[2];};
-
-template <class T>
-struct internal_member_value_traits
-{
- template <class U> static one test(...);
- template <class U> static two test(typename U::boost_move_emulation_t* = 0);
- static const bool value = sizeof(test<T>(0)) == sizeof(two);
-};
-
-} //namespace move_detail {
-
-/// @endcond
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// is_movable
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! For compilers with rvalue references, this traits class returns true
-//! if BOOST_ENABLE_MOVE_EMULATION is activated.
-//!
-//! For other compilers returns true if T is convertible to ::boost::rv<T>&
-template<class T>
-struct is_movable
- : public ::boost::mpl::bool_<move_detail::internal_member_value_traits<T>::value>
-{
-};

//! By default this traits returns false. Classes with non-thworing move construction
//! and assignment should specialize this trait to obtain some performance improvements.
template <class T>
struct has_nothrow_move
- : public ::boost::mpl::bool_<false>
+ : public BOOST_MOVE_MPL_NS::integral_constant<bool, false>
{};

//////////////////////////////////////////////////////////////////////////////
@@ -463,7 +446,7 @@

#else //BOOST_MOVE_DOXYGEN_INVOKED

-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ <= 5)
+#if defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)

//Old move approach, lvalues could bind to rvalue references
template <class T> inline
@@ -504,24 +487,26 @@

#else

-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ <= 5)
+#if defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)

//Old move approach, lvalues could bind to rvalue references

template <class T> inline
-T&& forward (typename move_detail::identity<T>::type&& t)
+T&& forward (typename BOOST_MOVE_MPL_NS::identity<T>::type&& t)
{ return t; }

#else //Old move

+//Implementation #5 from N2951, thanks to Howard Hinnant
+
template <class T, class U>
inline T&& forward(U&& t
- , typename enable_if_c<
- move_detail::is_lvalue_reference<T>::value ? move_detail::is_lvalue_reference::value : true>::type * = 0
- , typename enable_if_c<
+ , typename BOOST_MOVE_BOOST_NS::enable_if_c<
+ move_detail::is_lvalue_reference<T>::value ? move_detail::is_lvalue_reference::value : true>::type * = 0/*
+ , typename BOOST_MOVE_BOOST_NS::enable_if_c<
 move_detail::is_convertible
- <typename remove_reference::type*, typename remove_reference<T>::type*>::value>::type * = 0)
-{ return static_cast<T&&>(t); }
+ <typename remove_reference::type*, typename remove_reference<T>::type*>::value>::type * = 0*/)
+{ return static_cast<T&&>(t); }

#endif //Old move

@@ -557,7 +542,6 @@
//! The user will need to write a move constructor/assignment and a copy assignment
//! as explained in the documentation to fully write a copyable and movable class.
#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
- typedef int boost_move_emulation_t;
//

/// @cond
@@ -611,13 +595,11 @@

/// @endcond

-INTERPROCESS_NAMESPACE_END
} //namespace boost {

#endif //BOOST_NO_RVALUE_REFERENCES

namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN

//////////////////////////////////////////////////////////////////////////////
//
@@ -639,9 +621,9 @@
 #if !defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
 typedef value_type && reference;
 #else
- typedef typename ::boost::mpl::if_
- < ::BOOST_MOVE_NAMESPACE::is_movable<value_type>
- , ::BOOST_MOVE_NAMESPACE::rv<value_type>&
+ typedef typename BOOST_MOVE_MPL_NS::if_
+ < ::boost::has_move_emulation_enabled<value_type>
+ , ::boost::rv<value_type>&
 , value_type & >::type reference;
 #endif
 typedef It pointer;
@@ -665,10 +647,10 @@

 reference operator*() const
 {
- #if !defined(BOOST_NO_RVALUE_REFERENCES)
+ #if defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
 return *m_it;
 #else
- return ::BOOST_MOVE_NAMESPACE::move(*m_it);
+ return ::boost::move(*m_it);
 #endif
 }

@@ -701,10 +683,10 @@

 reference operator[](difference_type n) const
 {
- #if !defined(BOOST_NO_RVALUE_REFERENCES)
+ #if defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
 return m_it[n];
 #else
- return ::BOOST_MOVE_NAMESPACE::move(m_it[n]);
+ return ::boost::move(m_it[n]);
 #endif
 }

@@ -742,13 +724,13 @@

template <class I>
struct is_move_iterator
- : public ::boost::mpl::bool_<false>
+ : public BOOST_MOVE_MPL_NS::integral_constant<bool, false>
{
};

template <class I>
-struct is_move_iterator< ::BOOST_MOVE_NAMESPACE::move_iterator >
- : public ::boost::mpl::bool_<true>
+struct is_move_iterator< ::boost::move_iterator >
+ : public BOOST_MOVE_MPL_NS::integral_constant<bool, true>
{
};

@@ -787,7 +769,7 @@
 explicit back_move_insert_iterator(C& x) : container_m(&x) { }

 back_move_insert_iterator& operator=(typename C::reference x)
- { container_m->push_back(BOOST_MOVE_NAMESPACE::move(x)); return *this; }
+ { container_m->push_back(boost::move(x)); return *this; }

 back_move_insert_iterator& operator*() { return *this; }
 back_move_insert_iterator& operator++() { return *this; }
@@ -822,7 +804,7 @@
 explicit front_move_insert_iterator(C& x) : container_m(&x) { }

 front_move_insert_iterator& operator=(typename C::reference x)
- { container_m->push_front(BOOST_MOVE_NAMESPACE::move(x)); return *this; }
+ { container_m->push_front(boost::move(x)); return *this; }

 front_move_insert_iterator& operator*() { return *this; }
 front_move_insert_iterator& operator++() { return *this; }
@@ -858,7 +840,7 @@

 move_insert_iterator& operator=(typename C::reference x)
 {
- pos_ = container_m->insert(pos_, ::BOOST_MOVE_NAMESPACE::move(x));
+ pos_ = container_m->insert(pos_, ::boost::move(x));
 ++pos_;
 return *this;
 }
@@ -897,7 +879,7 @@
O move(I f, I l, O result)
{
 while (f != l) {
- *result = ::BOOST_MOVE_NAMESPACE::move(*f);
+ *result = ::boost::move(*f);
 ++f; ++result;
 }
 return result;
@@ -925,7 +907,7 @@
{
 while (f != l) {
 --l; --result;
- *result = ::BOOST_MOVE_NAMESPACE::move(*l);
+ *result = ::boost::move(*l);
 }
 return result;
}
@@ -949,29 +931,29 @@
 typename F> // F models ForwardIterator
F uninitialized_move(I f, I l, F r
 /// @cond
- ,typename enable_if<is_movable<typename std::iterator_traits::value_type> >::type* = 0
+// ,typename BOOST_MOVE_BOOST_NS::enable_if<has_move_emulation_enabled<typename std::iterator_traits::value_type> >::type* = 0
 /// @endcond
 )
{
 typedef typename std::iterator_traits::value_type input_value_type;
 while (f != l) {
- ::new(static_cast<void*>(&*r)) input_value_type(BOOST_MOVE_NAMESPACE::move(*f));
+ ::new(static_cast<void*>(&*r)) input_value_type(boost::move(*f));
 ++f; ++r;
 }
 return r;
}

/// @cond
-
+/*
template
 <typename I, // I models InputIterator
 typename F> // F models ForwardIterator
F uninitialized_move(I f, I l, F r,
- typename disable_if<is_movable<typename std::iterator_traits::value_type> >::type* = 0)
+ typename BOOST_MOVE_BOOST_NS::disable_if<has_move_emulation_enabled<typename std::iterator_traits::value_type> >::type* = 0)
{
 return std::uninitialized_copy(f, l, r);
}
-
+*/
//////////////////////////////////////////////////////////////////////////////
//
// uninitialized_copy_or_move
@@ -983,30 +965,70 @@
template
<typename I, // I models InputIterator
typename F> // F models ForwardIterator
-F uninitialized_move_move_iterator(I f, I l, F r,
- typename enable_if< is_movable<typename I::value_type> >::type* = 0)
+F uninitialized_move_move_iterator(I f, I l, F r
+// ,typename BOOST_MOVE_BOOST_NS::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0
+)
{
- return ::BOOST_MOVE_NAMESPACE::uninitialized_move(f, l, r);
+ return ::boost::uninitialized_move(f, l, r);
}
-
+/*
template
<typename I, // I models InputIterator
typename F> // F models ForwardIterator
F uninitialized_move_move_iterator(I f, I l, F r,
- typename disable_if< is_movable<typename I::value_type> >::type* = 0)
+ typename BOOST_MOVE_BOOST_NS::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0)
{
 return std::uninitialized_copy(f.base(), l.base(), r);
}
-
+*/
} //namespace move_detail {

template
<typename I, // I models InputIterator
typename F> // F models ForwardIterator
F uninitialized_copy_or_move(I f, I l, F r,
- typename enable_if< move_detail::is_move_iterator >::type* = 0)
+ typename BOOST_MOVE_BOOST_NS::enable_if< move_detail::is_move_iterator >::type* = 0)
+{
+ return ::boost::move_detail::uninitialized_move_move_iterator(f, l, r);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// copy_or_move
+//
+//////////////////////////////////////////////////////////////////////////////
+
+namespace move_detail {
+
+template
+<typename I, // I models InputIterator
+typename F> // F models ForwardIterator
+F move_move_iterator(I f, I l, F r
+// ,typename BOOST_MOVE_BOOST_NS::enable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0
+)
{
- return ::BOOST_MOVE_NAMESPACE::move_detail::uninitialized_move_move_iterator(f, l, r);
+ return ::boost::move(f, l, r);
+}
+/*
+template
+<typename I, // I models InputIterator
+typename F> // F models ForwardIterator
+F move_move_iterator(I f, I l, F r,
+ typename BOOST_MOVE_BOOST_NS::disable_if< has_move_emulation_enabled<typename I::value_type> >::type* = 0)
+{
+ return std::copy(f.base(), l.base(), r);
+}
+*/
+
+} //namespace move_detail {
+
+template
+<typename I, // I models InputIterator
+typename F> // F models ForwardIterator
+F copy_or_move(I f, I l, F r,
+ typename BOOST_MOVE_BOOST_NS::enable_if< move_detail::is_move_iterator >::type* = 0)
+{
+ return ::boost::move_detail::move_move_iterator(f, l, r);
}

/// @endcond
@@ -1028,13 +1050,36 @@
typename F> // F models ForwardIterator
F uninitialized_copy_or_move(I f, I l, F r
 /// @cond
- ,typename disable_if< move_detail::is_move_iterator >::type* = 0
+ ,typename BOOST_MOVE_BOOST_NS::disable_if< move_detail::is_move_iterator >::type* = 0
 /// @endcond
 )
{
 return std::uninitialized_copy(f, l, r);
}

+//! Effects:
+//! \code
+//! for (; first != last; ++result, ++first)
+//! *result = *first;
+//! \endcode
+//!
+//! Returns: result
+//!
+//! Note: This function is provided because
+//! std::uninitialized_copy from some STL implementations
+//! is not compatible with move_iterator
+template
+<typename I, // I models InputIterator
+typename F> // F models ForwardIterator
+F copy_or_move(I f, I l, F r
+ /// @cond
+ ,typename BOOST_MOVE_BOOST_NS::disable_if< move_detail::is_move_iterator >::type* = 0
+ /// @endcond
+ )
+{
+ return std::copy(f, l, r);
+}
+
//! If this trait yields to true
//! (has_trivial_destructor_after_move <T>::value == true)
//! means that if T is used as argument of a move construction/assignment,
@@ -1046,42 +1091,9 @@
//! when inserted in containers.
template <class T>
struct has_trivial_destructor_after_move
- : public ::boost::has_trivial_destructor<T>
+ : BOOST_MOVE_BOOST_NS::has_trivial_destructor<T>
{};

-#ifndef BOOST_MOVE_DOXYGEN_INVOKED
-
-#ifdef BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
-
-#define BOOST_INTERPROCESS_ENABLE_MOVE_EMULATION(TYPE) BOOST_ENABLE_MOVE_EMULATION(TYPE)
-#define BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)
-#define BOOST_INTERPROCESS_COPYABLE_AND_MOVABLE(TYPE) BOOST_COPYABLE_AND_MOVABLE(TYPE)
-#define BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_INTERPROCESS_RV_REF(TYPE) BOOST_RV_REF(TYPE)
-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE) BOOST_COPY_ASSIGN_REF(TYPE)
-#define BOOST_INTERPROCESS_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_INTERPROCESS_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_INTERPROCESS_FWD_REF(TYPE) BOOST_FWD_REF(TYPE)
-#define BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(TYPE) BOOST_CATCH_CONST_RLVALUE(TYPE)
-
-#endif
-
-#define BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION(TYPE) BOOST_ENABLE_MOVE_EMULATION(TYPE)
-#define BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)
-#define BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE) BOOST_COPYABLE_AND_MOVABLE(TYPE)
-#define BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_MOVE_MACRO_RV_REF(TYPE) BOOST_RV_REF(TYPE)
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE) BOOST_COPY_ASSIGN_REF(TYPE)
-#define BOOST_MOVE_MACRO_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_MOVE_MACRO_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_MOVE_MACRO_FWD_REF(TYPE) BOOST_FWD_REF(TYPE)
-#define BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE) BOOST_CATCH_CONST_RLVALUE(TYPE)
-
-#endif //BOOST_MOVE_DOXYGEN_INVOKED
-
-INTERPROCESS_NAMESPACE_END
} //namespace boost {

-#endif //#ifndef BOOST_MOVE_HPP
+#endif //#ifndef BOOST_MOVE_MOVE_HPP

Added: sandbox/move/boost/move/move_helpers.hpp
==============================================================================
--- (empty file)
+++ sandbox/move/boost/move/move_helpers.hpp 2011-07-21 19:05:18 EDT (Thu, 21 Jul 2011)
@@ -0,0 +1,173 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2010-2011.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_MOVE_HELPERS_HPP
+#define BOOST_MOVE_MOVE_HELPERS_HPP
+
+#include <boost/move/move.hpp>
+#include <boost/type_traits/is_class.hpp>
+
+#if defined(BOOST_NO_RVALUE_REFERENCES) || (defined(_MSC_VER) && (_MSC_VER == 1600))
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/enable_if.hpp>
+#endif
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+#include <boost/mpl/if.hpp>
+#endif
+
+
+#if defined(BOOST_NO_RVALUE_REFERENCES)
+struct not_a_type;
+#define BOOST_MOVE_CATCH_CONST(U) \
+ typename ::boost::mpl::if_< ::boost::is_class<T>, BOOST_CATCH_CONST_RLVALUE(U), const U &>::type
+#define BOOST_MOVE_CATCH_RVALUE(U)\
+ typename ::boost::mpl::if_< ::boost::is_class<T>, BOOST_RV_REF(T), not_a_type>::type
+#define BOOST_MOVE_CATCH_FWD(U) BOOST_FWD_REF(U)
+#else
+#define BOOST_MOVE_CATCH_CONST(U) const U &
+#define BOOST_MOVE_CATCH_RVALUE(U) U &&
+#define BOOST_MOVE_CATCH_FWD(U) U &&
+#endif
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+ { return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < ::boost::is_class<TYPE>::value &&\
+ ::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::has_move_emulation_enabled<BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ { return FWD_FUNCTION(u); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < ::boost::is_class<BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t(u);\
+ return FWD_FUNCTION(::boost::move(t));\
+ }\
+//
+
+#elif (defined(_MSC_VER) && (_MSC_VER == 1600))
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < !::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t(u);\
+ return FWD_FUNCTION(::boost::move(t));\
+ }\
+//
+
+#else
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(::boost::move(x)); }\
+//
+
+#endif
+
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+ { return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < ::boost::is_class<TYPE>::value &&\
+ ::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::has_move_emulation_enabled<BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ { return FWD_FUNCTION(arg1, u); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < ::boost::is_class<BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value &&\
+ !::boost::move_detail::is_rv<BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t(u);\
+ return FWD_FUNCTION(arg1, ::boost::move(t));\
+ }\
+//
+
+#elif (defined(_MSC_VER) && (_MSC_VER == 1600))
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+\
+ template<class BOOST_MOVE_TEMPL_PARAM>\
+ typename ::boost::enable_if_c\
+ < !::boost::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
+ , RETURN_VALUE >::type\
+ PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
+ {\
+ TYPE t(u);\
+ return FWD_FUNCTION(arg1, ::boost::move(t));\
+ }\
+//
+
+#else
+
+#define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1)\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+ { return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
+\
+ RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+ { return FWD_FUNCTION(arg1, ::boost::move(x)); }\
+//
+
+#endif
+
+#endif //#ifndef BOOST_MOVE_MOVE_HELPERS_HPP

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