Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r60514 - in trunk/boost: interprocess interprocess/containers/container interprocess/containers/container/detail interprocess/detail interprocess/smart_ptr intrusive intrusive/detail
From: igaztanaga_at_[hidden]
Date: 2010-03-12 08:18:36

Next message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r60515 - in trunk/libs: interprocess/proj/vc7ide interprocess/test intrusive/test"
Previous message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r60513 - trunk/boost/interprocess/detail"

Author: igaztanaga
Date: 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
New Revision: 60514
URL: http://svn.boost.org/trac/boost/changeset/60514

Log:
Interprocess:
  [@https://svn.boost.org/trac/boost/ticket/3439 #3439],
  [@https://svn.boost.org/trac/boost/ticket/3846 #3846],
  [@https://svn.boost.org/trac/boost/ticket/3947 #3947],
  [@https://svn.boost.org/trac/boost/ticket/3985 #3985].
Intrusive:
  [@https://svn.boost.org/trac/boost/ticket/3668 #3668],
  [@https://svn.boost.org/trac/boost/ticket/3339 #3688],
  [@https://svn.boost.org/trac/boost/ticket/3698 #3698],
  [@https://svn.boost.org/trac/boost/ticket/3706 #3706],
  [@https://svn.boost.org/trac/boost/ticket/3721 #3721].
  [@https://svn.boost.org/trac/boost/ticket/3729 #3729],
  [@https://svn.boost.org/trac/boost/ticket/3746 #3746],
  [@https://svn.boost.org/trac/boost/ticket/3781 #3781],
  [@https://svn.boost.org/trac/boost/ticket/3829 #3829],
  [@https://svn.boost.org/trac/boost/ticket/3840 #3840],
  [@https://svn.boost.org/trac/boost/ticket/3339 #3339],
  [@https://svn.boost.org/trac/boost/ticket/3419 #3419],
  [@https://svn.boost.org/trac/boost/ticket/3431 #3431],
Text files modified:
   trunk/boost/interprocess/containers/container/deque.hpp | 96 ++++++++--------
   trunk/boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp | 22 +-
   trunk/boost/interprocess/containers/container/detail/advanced_insert_int.hpp | 38 +++---
   trunk/boost/interprocess/containers/container/detail/algorithms.hpp | 12 +-
   trunk/boost/interprocess/containers/container/detail/allocation_type.hpp | 6
   trunk/boost/interprocess/containers/container/detail/config_begin.hpp | 97 +++++++++++++++++
   trunk/boost/interprocess/containers/container/detail/destroyers.hpp | 10
   trunk/boost/interprocess/containers/container/detail/flat_tree.hpp | 94 ++++++++--------
   trunk/boost/interprocess/containers/container/detail/iterators.hpp | 14 +-
   trunk/boost/interprocess/containers/container/detail/multiallocation_chain.hpp | 36 +++---
   trunk/boost/interprocess/containers/container/detail/node_alloc_holder.hpp | 56 +++++-----
   trunk/boost/interprocess/containers/container/detail/node_pool_impl.hpp | 20 +-
   trunk/boost/interprocess/containers/container/detail/pair.hpp | 58 +++++-----
   trunk/boost/interprocess/containers/container/detail/pool_common.hpp | 4
   trunk/boost/interprocess/containers/container/detail/preprocessor.hpp | 10
   trunk/boost/interprocess/containers/container/detail/transform_iterator.hpp | 8
   trunk/boost/interprocess/containers/container/detail/tree.hpp | 64 +++++-----
   trunk/boost/interprocess/containers/container/detail/type_traits.hpp | 4
   trunk/boost/interprocess/containers/container/detail/utilities.hpp | 12 +-
   trunk/boost/interprocess/containers/container/detail/value_init.hpp | 6
   trunk/boost/interprocess/containers/container/detail/variadic_templates_tools.hpp | 8
   trunk/boost/interprocess/containers/container/detail/version_type.hpp | 6
   trunk/boost/interprocess/containers/container/detail/workaround.hpp | 6
   trunk/boost/interprocess/containers/container/flat_map.hpp | 82 +++++++-------
   trunk/boost/interprocess/containers/container/flat_set.hpp | 70 ++++++------
   trunk/boost/interprocess/containers/container/list.hpp | 58 +++++-----
   trunk/boost/interprocess/containers/container/map.hpp | 104 +++++++++---------
   trunk/boost/interprocess/containers/container/set.hpp | 74 ++++++------
   trunk/boost/interprocess/containers/container/slist.hpp | 58 +++++-----
   trunk/boost/interprocess/containers/container/stable_vector.hpp | 52 ++++----
   trunk/boost/interprocess/containers/container/string.hpp | 75 ++++++------
   trunk/boost/interprocess/containers/container/vector.hpp | 106 +++++++++---------
   trunk/boost/interprocess/detail/atomic.hpp | 2
   trunk/boost/interprocess/detail/managed_memory_impl.hpp | 11 +
   trunk/boost/interprocess/detail/move.hpp | 224 ++++++++++++++++++++++++---------------
   trunk/boost/interprocess/detail/os_file_functions.hpp | 17 ++
   trunk/boost/interprocess/detail/tmp_dir_helpers.hpp | 40 +++---
   trunk/boost/interprocess/detail/win32_api.hpp | 19 +++
   trunk/boost/interprocess/managed_shared_memory.hpp | 1
   trunk/boost/interprocess/offset_ptr.hpp | 2
   trunk/boost/interprocess/segment_manager.hpp | 18 +++
   trunk/boost/interprocess/shared_memory_object.hpp | 2
   trunk/boost/interprocess/smart_ptr/shared_ptr.hpp | 2
   trunk/boost/interprocess/windows_shared_memory.hpp | 1
   trunk/boost/intrusive/avl_set.hpp | 4
   trunk/boost/intrusive/avltree.hpp | 6
   trunk/boost/intrusive/avltree_algorithms.hpp | 2
   trunk/boost/intrusive/derivation_value_traits.hpp | 4
   trunk/boost/intrusive/detail/hashtable_node.hpp | 9
   trunk/boost/intrusive/detail/list_node.hpp | 24 +--
   trunk/boost/intrusive/detail/slist_node.hpp | 24 +--
   trunk/boost/intrusive/detail/tree_algorithms.hpp | 4
   trunk/boost/intrusive/detail/tree_node.hpp | 25 +--
   trunk/boost/intrusive/detail/utilities.hpp | 68 +++++++++++
   trunk/boost/intrusive/hashtable.hpp | 38 +++---
   trunk/boost/intrusive/list.hpp | 27 +++
   trunk/boost/intrusive/member_value_traits.hpp | 4
   trunk/boost/intrusive/rbtree.hpp | 27 +++-
   trunk/boost/intrusive/rbtree_algorithms.hpp | 2
   trunk/boost/intrusive/set.hpp | 23 +++
   trunk/boost/intrusive/sgtree.hpp | 4
   trunk/boost/intrusive/sgtree_algorithms.hpp | 2
   trunk/boost/intrusive/slist.hpp | 36 ++++-
   trunk/boost/intrusive/splay_set.hpp | 4
   trunk/boost/intrusive/splaytree.hpp | 4
   trunk/boost/intrusive/splaytree_algorithms.hpp | 2
   trunk/boost/intrusive/treap.hpp | 6
   trunk/boost/intrusive/treap_algorithms.hpp | 2
   trunk/boost/intrusive/treap_set.hpp | 4
   trunk/boost/intrusive/unordered_set.hpp | 40 +++---
   70 files changed, 1216 insertions(+), 884 deletions(-)

Modified: trunk/boost/interprocess/containers/container/deque.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/deque.hpp (original)
+++ trunk/boost/interprocess/containers/container/deque.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -48,14 +48,14 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/iterators.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <cstddef>
#include <iterator>
#include <cassert>
@@ -68,8 +68,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 <boost/interprocess/detail/move.hpp>
-#include <boost/interprocess/containers/container/detail/advanced_insert_int.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -532,13 +532,13 @@

 /// @cond
 private: // Internal typedefs
- BOOST_COPYABLE_AND_MOVABLE(deque)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(deque)
 typedef ptr_alloc_ptr index_pointer;
 static std::size_t 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::interprocess::move_iterator<r_iterator> move_it;
+ typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<r_iterator> move_it;

 /// @endcond

@@ -628,7 +628,7 @@
 }
 }

- deque(BOOST_INTERPROCESS_RV_REF(deque) mx)
+ deque(BOOST_MOVE_MACRO_RV_REF(deque) mx)
 : Base(mx.alloc())
 { this->swap(mx); }

@@ -655,7 +655,7 @@
 priv_destroy_range(this->members_.m_start, this->members_.m_finish);
 }

- deque& operator= (BOOST_INTERPROCESS_COPY_ASSIGN_REF(deque) x)
+ deque& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(deque) x)
 {
 const size_type len = size();
 if (&x != this) {
@@ -670,7 +670,7 @@
 return *this;
 }

- deque& operator= (BOOST_INTERPROCESS_RV_REF(deque) x)
+ deque& operator= (BOOST_MOVE_MACRO_RV_REF(deque) x)
 {
 this->clear();
 this->swap(x);
@@ -701,17 +701,17 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_push_back(u); }
 #endif

 void push_back(insert_const_ref_type t)
 { return priv_push_back(t); }

- void push_back(BOOST_INTERPROCESS_RV_REF(value_type) 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::interprocess::move(t));
+ new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
 this->priv_push_back_simple_commit();
 }
 else{
@@ -723,17 +723,17 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_push_front(u); }
 #endif

 void push_front(insert_const_ref_type t)
 { return priv_push_front(t); }

- void push_front(BOOST_INTERPROCESS_RV_REF(value_type) 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::interprocess::move(t));
+ new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
 this->priv_push_front_simple_commit();
 }
 else{
@@ -766,21 +766,21 @@
 { 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

 iterator insert(const_iterator position, insert_const_ref_type x)
 { return this->priv_insert(position, x); }

- iterator insert(const_iterator position, BOOST_INTERPROCESS_RV_REF(value_type) mx)
+ iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) mx)
 {
 if (position == cbegin()) {
- this->push_front(boost::interprocess::move(mx));
+ this->push_front(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
 return begin();
 }
 else if (position == cend()) {
- this->push_back(boost::interprocess::move(mx));
+ this->push_back(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
 return(end()-1);
 }
 else {
@@ -810,12 +810,12 @@
 void emplace_back(Args&&... args)
 {
 if(this->priv_push_back_simple_available()){
- new(this->priv_push_back_simple_pos())value_type(boost::interprocess::forward<Args>(args)...);
+ new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...);
+ type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 this->priv_insert_aux_impl(this->cend(), 1, proxy);
 }
 }
@@ -824,12 +824,12 @@
 void emplace_front(Args&&... args)
 {
 if(this->priv_push_front_simple_available()){
- new(this->priv_push_front_simple_pos())value_type(boost::interprocess::forward<Args>(args)...);
+ new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...);
+ type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 this->priv_insert_aux_impl(this->cbegin(), 1, proxy);
 }
 }
@@ -838,17 +838,17 @@
 iterator emplace(const_iterator p, Args&&... args)
 {
 if(p == this->cbegin()){
- this->emplace_front(boost::interprocess::forward<Args>(args)...);
+ this->emplace_front(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 return this->begin();
 }
 else if(p == this->cend()){
- this->emplace_back(boost::interprocess::forward<Args>(args)...);
+ this->emplace_back(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...);
+ type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 this->priv_insert_aux_impl(p, 1, proxy);
 return iterator(this->begin() + n);
 }
@@ -986,11 +986,11 @@
 ++next;
 difference_type index = pos - this->members_.m_start;
 if (size_type(index) < (this->size() >> 1)) {
- boost::interprocess::move_backward(begin(), iterator(pos), iterator(next));
+ BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(begin(), iterator(pos), iterator(next));
 pop_front();
 }
 else {
- boost::interprocess::move(iterator(next), end(), iterator(pos));
+ BOOST_CONTAINER_MOVE_NAMESPACE::move(iterator(next), end(), iterator(pos));
 pop_back();
 }
 return this->members_.m_start + index;
@@ -1006,7 +1006,7 @@
 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::interprocess::move_backward(begin(), iterator(first), iterator(last));
+ BOOST_CONTAINER_MOVE_NAMESPACE::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);
@@ -1014,7 +1014,7 @@
 this->members_.m_start = new_start;
 }
 else {
- boost::interprocess::move(iterator(last), end(), iterator(first));
+ BOOST_CONTAINER_MOVE_NAMESPACE::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);
@@ -1120,7 +1120,7 @@
 void priv_insert_aux(const_iterator pos, InpIt first, InpIt last, std::input_iterator_tag)
 {
 for(;first != last; ++first){
- this->insert(pos, boost::interprocess::move(value_type(*first)));
+ this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
 }
 }

@@ -1248,9 +1248,9 @@
 pos = this->members_.m_start + elemsbefore;
 if (elemsbefore >= difference_type(n)) {
 iterator start_n = this->members_.m_start + difference_type(n);
- ::boost::interprocess::uninitialized_move(this->members_.m_start, start_n, new_start);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(this->members_.m_start, start_n, new_start);
 this->members_.m_start = new_start;
- boost::interprocess::move(start_n, pos, old_start);
+ BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
 interf.copy_all_to(pos - difference_type(n));
 }
 else {
@@ -1258,7 +1258,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::interprocess::uninitialized_move(old_start, pos, new_start);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
 this->members_.m_start = new_start;
 interf.copy_all_to(old_start);
 }
@@ -1271,15 +1271,15 @@
 pos = this->members_.m_finish - elemsafter;
 if (elemsafter >= difference_type(n)) {
 iterator finish_n = this->members_.m_finish - difference_type(n);
- ::boost::interprocess::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
 this->members_.m_finish = new_finish;
- boost::interprocess::move_backward(pos, finish_n, old_finish);
+ BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::uninitialized_move(pos, old_finish, this->members_.m_finish);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, old_finish, this->members_.m_finish);
 this->members_.m_finish = new_finish;
 interf.copy_all_to(pos);
 }
@@ -1339,10 +1339,10 @@
 ++cur_node) {
 FwdIt mid = first;
 std::advance(mid, this->s_buffer_size());
- ::boost::interprocess::uninitialized_copy_or_move(first, mid, *cur_node);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, mid, *cur_node);
 first = mid;
 }
- ::boost::interprocess::uninitialized_copy_or_move(first, last, this->members_.m_finish.m_first);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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));
@@ -1433,9 +1433,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::interprocess::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ BOOST_CONTAINER_MOVE_NAMESPACE::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
 else
- boost::interprocess::move_backward
+ BOOST_CONTAINER_MOVE_NAMESPACE::move_backward
 (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
 }
 else {
@@ -1445,7 +1445,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::interprocess::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1516,6 +1516,6 @@

/// @endcond

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // #ifndef BOOST_CONTAINERS_DEQUE_HPP

Modified: trunk/boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,17 +15,17 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include <boost/pointer_to_other.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/slist.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
-#include <boost/interprocess/containers/container/detail/math_functions.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/pool_common.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#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 <cstddef>

@@ -270,11 +270,11 @@
 }
 }
 catch(...){
- this->deallocate_nodes(boost::interprocess::move(chain));
+ this->deallocate_nodes(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
 throw;
 }
 priv_invariants();
- return boost::interprocess::move(chain);
+ return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
 }

 //!Deallocates a linked list of nodes. Never throws
@@ -633,6 +633,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP

Modified: trunk/boost/interprocess/containers/container/detail/advanced_insert_int.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/advanced_insert_int.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/advanced_insert_int.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,9 +15,9 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
#include <iterator> //std::iterator_traits
#include <algorithm> //std::copy, std::uninitialized_copy
#include <new> //placement new
@@ -54,18 +54,18 @@
 { std::copy(first_, last_, p); }

 virtual void uninitialized_copy_all_to(Iterator p)
- { ::boost::interprocess::uninitialized_copy_or_move(first_, last_, p); }
+ { ::BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::uninitialized_copy_or_move(first_, mid, pos);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first_, mid, pos);
 first_ = mid;
 }
 else{
- ::boost::interprocess::uninitialized_copy_or_move(mid, last_, pos);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(mid, last_, pos);
 last_ = mid;
 }
 }
@@ -163,8 +163,8 @@

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

-#include <boost/interprocess/containers/container/detail/variadic_templates_tools.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
#include <typeinfo>
//#include <iostream> //For debugging purposes

@@ -204,7 +204,7 @@
 void priv_copy_all_to(const index_tuple<IdxPack...>&, Iterator p)
 {
 if(!used_){
- *p = boost::interprocess::move(T (boost::interprocess::forward<Args>(get<IdxPack>(args_))...));
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T (BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...));
 used_ = true;
 }
 }
@@ -213,7 +213,7 @@
 void priv_uninitialized_copy_all_to(const index_tuple<IdxPack...>&, Iterator p)
 {
 if(!used_){
- new(containers_detail::get_pointer(&*p))T(boost::interprocess::forward<Args>(get<IdxPack>(args_))...);
+ new(containers_detail::get_pointer(&*p))T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...);
 used_ = true;
 }
 }
@@ -224,7 +224,7 @@
 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::interprocess::forward<Args>(get<IdxPack>(args_))...);
+ new(containers_detail::get_pointer(&*p))T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...);
 used_ = true;
 }
 }
@@ -236,7 +236,7 @@
 assert(division_count <=1);
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
- *p = boost::interprocess::move(T(boost::interprocess::forward<Args>(get<IdxPack>(args_))...));
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(get<IdxPack>(args_))...));
 used_ = true;
 }
 }
@@ -249,8 +249,8 @@

#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
-#include <boost/interprocess/containers/container/detail/value_init.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VALUE_INIT_HPP

namespace boost {
namespace container {
@@ -273,7 +273,7 @@
 {
 if(!used_){
 value_init<T>v;
- *p = boost::interprocess::move(v.m_t);
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
 used_ = true;
 }
 }
@@ -303,7 +303,7 @@
 if((first_n && division_count == 1) || (!first_n && division_count == 0)){
 if(!used_){
 value_init<T>v;
- *p = boost::interprocess::move(v.m_t);
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
 used_ = true;
 }
 }
@@ -327,7 +327,7 @@
 { \
 if(!used_){ \
 T v(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_MEMBER_FORWARD, _)); \
- *p = boost::interprocess::move(v); \
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v); \
 used_ = true; \
 } \
 } \
@@ -361,7 +361,7 @@
 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::interprocess::move(v); \
+ *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v); \
 used_ = true; \
 } \
 } \
@@ -379,6 +379,6 @@

#endif //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_ADVANCED_INSERT_INT_HPP

Modified: trunk/boost/interprocess/containers/container/detail/algorithms.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/algorithms.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -17,17 +17,17 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

#include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/get_pointer.hpp>

-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/iterators.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP

#include <cstring>
@@ -209,7 +209,7 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_ALGORITHMS_HPP

Modified: trunk/boost/interprocess/containers/container/detail/allocation_type.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/allocation_type.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/allocation_type.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,8 +15,8 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

namespace boost {
namespace container {
@@ -49,6 +49,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //BOOST_CONTAINERS_ALLOCATION_TYPE_HPP

Modified: trunk/boost/interprocess/containers/container/detail/config_begin.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/config_begin.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/config_begin.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -10,6 +10,103 @@
#ifndef BOOST_CONTAINERS_CONTAINER_DETAIL_CONFIG_INCLUDED
#define BOOST_CONTAINERS_CONTAINER_DETAIL_CONFIG_INCLUDED
#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
+
+#define INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP <boost/interprocess/containers/container/container_fwd.hpp>
+#define INCLUDE_BOOST_CONTAINER_DEQUE_HPP <boost/interprocess/containers/container/deque.hpp>
+#define INCLUDE_BOOST_CONTAINER_FLAT_MAP_HPP <boost/interprocess/containers/container/flat_map.hpp>
+#define INCLUDE_BOOST_CONTAINER_FLAT_SET_HPP <boost/interprocess/containers/container/flat_set.hpp>
+#define INCLUDE_BOOST_CONTAINER_LIST_HPP <boost/interprocess/containers/container/list.hpp>
+#define INCLUDE_BOOST_CONTAINER_MAP_HPP <boost/interprocess/containers/container/map.hpp>
+#define INCLUDE_BOOST_CONTAINER_SET_HPP <boost/interprocess/containers/container/set.hpp>
+#define INCLUDE_BOOST_CONTAINER_SLIST_HPP <boost/interprocess/containers/container/slist.hpp>
+#define INCLUDE_BOOST_CONTAINER_STABLE_VECTOR_HPP <boost/interprocess/containers/container/stable_vector.hpp>
+#define INCLUDE_BOOST_CONTAINER_STRING_HPP <boost/interprocess/containers/container/string.hpp>
+#define INCLUDE_BOOST_CONTAINER_VECTOR_HPP <boost/interprocess/containers/container/vector.hpp>
+//detail
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP <boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP <boost/interprocess/containers/container/detail/advanced_insert_int.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP <boost/interprocess/containers/container/detail/algorithms.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP <boost/interprocess/containers/container/detail/allocation_type.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP <boost/interprocess/containers/container/detail/config_end.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP <boost/interprocess/containers/container/detail/destroyers.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP <boost/interprocess/containers/container/detail/flat_tree.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP <boost/interprocess/containers/container/detail/iterators.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP <boost/interprocess/containers/container/detail/math_functions.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP <boost/interprocess/containers/container/detail/mpl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MULTIALLOCATION_CHAIN_HPP <boost/interprocess/containers/container/detail/multiallocation_chain.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP <boost/interprocess/containers/container/detail/node_alloc_holder.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_NODE_POOL_IMPL_HPP <boost/interprocess/containers/container/detail/node_pool_impl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP <boost/interprocess/containers/container/detail/pair.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_POOL_COMMON_HPP <boost/interprocess/containers/container/detail/pool_common.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP <boost/interprocess/containers/container/detail/transform_iterator.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP <boost/interprocess/containers/container/detail/tree.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP <boost/interprocess/containers/container/detail/type_traits.hpp>
+#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_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>
+
+#else //BOOST_CONTAINER_IN_INTERPROCESS
+
+#define INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP <boost/container/container_fwd.hpp>
+#define INCLUDE_BOOST_CONTAINER_DEQUE_HPP <boost/container/deque.hpp>
+#define INCLUDE_BOOST_CONTAINER_FLAT_MAP_HPP <boost/container/flat_map.hpp>
+#define INCLUDE_BOOST_CONTAINER_FLAT_SET_HPP <boost/container/flat_set.hpp>
+#define INCLUDE_BOOST_CONTAINER_LIST_HPP <boost/container/list.hpp>
+#define INCLUDE_BOOST_CONTAINER_MAP_HPP <boost/container/map.hpp>
+#define INCLUDE_BOOST_CONTAINER_SET_HPP <boost/container/set.hpp>
+#define INCLUDE_BOOST_CONTAINER_SLIST_HPP <boost/container/slist.hpp>
+#define INCLUDE_BOOST_CONTAINER_STABLE_VECTOR_HPP <boost/container/stable_vector.hpp>
+#define INCLUDE_BOOST_CONTAINER_STRING_HPP <boost/container/string.hpp>
+#define INCLUDE_BOOST_CONTAINER_VECTOR_HPP <boost/container/vector.hpp>
+//detail
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP <boost/container/detail/adaptive_node_pool_impl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP <boost/container/detail/advanced_insert_int.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP <boost/container/detail/algorithms.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP <boost/container/detail/allocation_type.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_BEGIN_HPP <boost/container/detail/config_begin.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP <boost/container/detail/config_end.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP <boost/container/detail/destroyers.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP <boost/container/detail/flat_tree.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP <boost/container/detail/iterators.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MATH_FUNCTIONS_HPP <boost/container/detail/math_functions.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP <boost/container/detail/mpl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_MULTIALLOCATION_CHAIN_HPP <boost/container/detail/multiallocation_chain.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP <boost/container/detail/node_alloc_holder.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_NODE_POOL_IMPL_HPP <boost/container/detail/node_pool_impl.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP <boost/container/detail/pair.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_POOL_COMMON_HPP <boost/container/detail/pool_common.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP <boost/container/detail/preprocessor.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP <boost/container/detail/transform_iterator.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP <boost/container/detail/tree.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP <boost/container/detail/type_traits.hpp>
+#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_VERSION_TYPE_HPP <boost/container/detail/version_type.hpp>
+#define INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP <boost/container/detail/workaround.hpp>
+
+#endif //BOOST_CONTAINER_IN_INTERPROCESS
+
#endif

#ifdef BOOST_MSVC

Modified: trunk/boost/interprocess/containers/container/detail/destroyers.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/destroyers.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/destroyers.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -17,10 +17,10 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP

namespace boost {
namespace container {
@@ -149,6 +149,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DESTROYERS_HPP

Modified: trunk/boost/interprocess/containers/container/detail/flat_tree.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/flat_tree.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/flat_tree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -32,23 +32,23 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP

#include <algorithm>
#include <functional>
#include <utility>

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

-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/pair.hpp>
-#include <boost/interprocess/containers/container/vector.hpp>
-#include <boost/interprocess/containers/container/detail/value_init.hpp>
-#include <boost/interprocess/containers/container/detail/destroyers.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
+#include INCLUDE_BOOST_CONTAINER_VECTOR_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VALUE_INIT_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP

namespace boost {

@@ -94,7 +94,7 @@
 : public value_compare
 {
 private:
- BOOST_COPYABLE_AND_MOVABLE(Data)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(Data)
 public:
 Data(const Data &d)
 : value_compare(d), m_vect(d.m_vect)
@@ -111,17 +111,17 @@
 const allocator_t &alloc)
 : value_compare(comp), m_vect(alloc){}

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

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

@@ -129,7 +129,7 @@
 };

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

 public:

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

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

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

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

- flat_tree& operator=(BOOST_INTERPROCESS_RV_REF(flat_tree) mx)
- { m_data = boost::interprocess::move(mx.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; }

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

- std::pair<iterator,bool> insert_unique(BOOST_INTERPROCESS_RV_REF(value_type) val)
+ std::pair<iterator,bool> insert_unique(BOOST_MOVE_MACRO_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::interprocess::move(val));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
 }
 return ret;
 }
@@ -279,10 +279,10 @@
 return i;
 }

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

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

- iterator insert_unique(const_iterator pos, BOOST_INTERPROCESS_RV_REF(value_type) mval)
+ iterator insert_unique(const_iterator pos, BOOST_MOVE_MACRO_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::interprocess::move(mval));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
 }
 return ret.first;
 }
@@ -313,11 +313,11 @@
 return priv_insert_commit(data, val);
 }

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

 template <class InIt>
@@ -340,12 +340,12 @@
 template <class... Args>
 iterator emplace_unique(Args&&... args)
 {
- value_type && val = value_type(boost::interprocess::forward<Args>(args)...);
+ value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::move<value_type>(val));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 }
 return ret.first;
 }
@@ -353,11 +353,11 @@
 template <class... Args>
 iterator emplace_hint_unique(const_iterator hint, Args&&... args)
 {
- value_type && val = value_type(boost::interprocess::forward<Args>(args)...);
+ value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::move<value_type>(val));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 }
 return ret.first;
 }
@@ -365,19 +365,19 @@
 template <class... Args>
 iterator emplace_equal(Args&&... args)
 {
- value_type &&val = value_type(boost::interprocess::forward<Args>(args)...);
+ value_type &&val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 iterator i = this->upper_bound(KeyOfValue()(val));
- i = this->m_data.m_vect.insert(i, boost::interprocess::move<value_type>(val));
+ i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 return i;
 }

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

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -390,7 +390,7 @@
 std::pair<iterator,bool> ret =
 priv_insert_unique_prepare(val, data);
 if(ret.second){
- ret.first = priv_insert_commit(data, boost::interprocess::move<value_type>(val));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 }
 return ret.first;
 }
@@ -402,7 +402,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::interprocess::move<value_type>(val));
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 }
 return ret.first;
 }
@@ -412,7 +412,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::interprocess::move<value_type>(val));
+ i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val));
 return i;
 }

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

 #define BOOST_PP_LOCAL_MACRO(n) \
@@ -433,7 +433,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::interprocess::move<value_type>(val)); \
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
 } \
 return ret.first; \
 } \
@@ -446,7 +446,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::interprocess::move<value_type>(val)); \
+ ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
 } \
 return ret.first; \
 } \
@@ -456,7 +456,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::interprocess::move<value_type>(val)); \
+ i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
 return i; \
 } \
 \
@@ -467,7 +467,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::interprocess::move<value_type>(val)); \
+ return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move<value_type>(val)); \
 } \
 //!
 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINERS_MAX_CONSTRUCTOR_PARAMETERS)
@@ -663,11 +663,11 @@

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

 template <class RanIt>
@@ -856,6 +856,6 @@
*/
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // BOOST_CONTAINERS_FLAT_TREE_HPP

Modified: trunk/boost/interprocess/containers/container/detail/iterators.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/iterators.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/iterators.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -18,14 +18,14 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
-#include <boost/interprocess/containers/container/detail/variadic_templates_tools.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
#else
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

#include <iterator>
@@ -447,7 +447,7 @@

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

 containers_detail::tuple<Args&&...> args_;
};
@@ -486,7 +486,7 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_ITERATORS_HPP

Modified: trunk/boost/interprocess/containers/container/detail/multiallocation_chain.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/multiallocation_chain.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/multiallocation_chain.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -11,14 +11,14 @@
#ifndef BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP
#define BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
-#include <boost/interprocess/containers/container/detail/transform_iterator.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP
#include <boost/intrusive/slist.hpp>
#include <boost/pointer_to_other.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP

namespace boost {
namespace container {
@@ -41,7 +41,7 @@
 static node & to_node(VoidPointer p)
 { return *static_cast<node*>(static_cast<void*>(containers_detail::get_pointer(p))); }

- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
+ BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)

 public:

@@ -53,13 +53,13 @@
 : slist_impl_()
 {}

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

- basic_multiallocation_chain& operator=(BOOST_INTERPROCESS_RV_REF(basic_multiallocation_chain) other)
+ basic_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
 {
- basic_multiallocation_chain tmp(boost::interprocess::move(other));
+ basic_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
 this->swap(tmp);
 return *this;
 }
@@ -144,7 +144,7 @@
class transform_multiallocation_chain
{
 private:
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)
+ BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)

 MultiallocationChain holder_;
 typedef typename MultiallocationChain::void_pointer void_pointer;
@@ -165,17 +165,17 @@
 : holder_()
 {}

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

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

- transform_multiallocation_chain& operator=(BOOST_INTERPROCESS_RV_REF(transform_multiallocation_chain) other)
+ transform_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
 {
- transform_multiallocation_chain tmp(boost::interprocess::move(other));
+ transform_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
 this->swap(tmp);
 return *this;
 }
@@ -230,7 +230,7 @@

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

@@ -240,6 +240,6 @@
// namespace container {
// namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP

Modified: trunk/boost/interprocess/containers/container/detail/node_alloc_holder.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/node_alloc_holder.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/node_alloc_holder.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,26 +15,26 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

#include <utility>
#include <functional>

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

-#include <boost/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/destroyers.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP

#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP

namespace boost {
@@ -60,7 +60,7 @@
 void priv_deallocate(allocator_v2)
 { m_alloc.deallocate_one(m_ptr); }

- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
+ BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)

 public:

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

- scoped_deallocator(BOOST_INTERPROCESS_RV_REF(scoped_deallocator) o)
+ scoped_deallocator(BOOST_MOVE_MACRO_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::interprocess::move(c_));
+ a_.deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(c_));
 }
};

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

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

 public:

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

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

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

- node_alloc_holder & operator=(BOOST_INTERPROCESS_RV_REF(node_alloc_holder) other)
+ node_alloc_holder & operator=(BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF(ValAlloc) a, const Pred &c)
+ node_alloc_holder(BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF_2_TEMPL_ARGS(std::pair, Convertible1, Convertible2) value)
+ BOOST_MOVE_MACRO_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::interprocess::move(value.first));
+ new((void*)&valueptr->first) first_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(value.first));
 BOOST_TRY{
- new((void*)&valueptr->second) second_type(boost::interprocess::move(value.second));
+ new((void*)&valueptr->second) second_type(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...); }
+ { new((void*)containers_detail::get_pointer(ptr)) Node(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...);
+ self_t::construct(p, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 node_deallocator.release();
 return (p);
 }
@@ -383,7 +383,7 @@
 if(constructed){
 this->destroy(p);
 }
- this->node_alloc().deallocate_individual(boost::interprocess::move(mem));
+ this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::is_movable<typename NodeAlloc::multiallocation_chain>::value == true));
+ BOOST_STATIC_ASSERT((::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<typename NodeAlloc::multiallocation_chain>::value == true));
 if(!chain.empty())
- this->node_alloc().deallocate_individual(boost::interprocess::move(chain));
+ this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
 }

 icont_iterator erase_range(icont_iterator first, icont_iterator last, allocator_v1)
@@ -496,6 +496,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // BOOST_CONTAINERS_DETAIL_NODE_ALLOC_HPP_

Modified: trunk/boost/interprocess/containers/container/detail/node_pool_impl.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/node_pool_impl.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/node_pool_impl.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,17 +15,17 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include <boost/pointer_to_other.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/slist.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
-#include <boost/interprocess/containers/container/detail/math_functions.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/pool_common.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
+#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 <cstddef>
#include <functional> //std::unary_function
@@ -120,7 +120,7 @@
 multiallocation_chain chain;
 chain.incorporate_after(chain.before_begin(), &*first_node, &*last_node, n);
 m_allocated += n;
- return boost::interprocess::move(chain);
+ return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
 }

 void deallocate_nodes(multiallocation_chain chain)
@@ -361,6 +361,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP

Modified: trunk/boost/interprocess/containers/container/detail/pair.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/pair.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/pair.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -17,18 +17,18 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP

#include <utility> //std::pair

-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP

#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

namespace boost {
@@ -39,7 +39,7 @@
struct pair
{
 private:
- BOOST_COPYABLE_AND_MOVABLE(pair)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(pair)

 public:
 typedef T1 first_type;
@@ -61,8 +61,8 @@
 {}

 template <class D, class S>
- pair(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
- : first(boost::interprocess::move(p.first)), second(boost::interprocess::move(p.second))
+ 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()
@@ -79,21 +79,21 @@
 : first(x.first), second(x.second)
 {}

- pair(BOOST_INTERPROCESS_RV_REF(pair) p)
- : first(boost::interprocess::move(p.first)), second(boost::interprocess::move(p.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(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
- : first(boost::interprocess::move(p.first)), second(boost::interprocess::move(p.second))
+ 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))
 {}

 #ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

 template<class U, class ...Args>
 pair(U &&u, Args &&... args)
- : first(boost::interprocess::forward(u))
- , second(boost::interprocess::forward<Args>(args)...)
+ : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(u))
+ , second(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
 {}

 #else
@@ -102,17 +102,17 @@
 pair( BOOST_CONTAINERS_PARAM(U, u)
 #ifndef BOOST_HAS_RVALUE_REFS
 , typename containers_detail::disable_if
- < containers_detail::is_same<U, ::boost::interprocess::rv<pair> > >::type* = 0
+ < containers_detail::is_same<U, ::BOOST_CONTAINER_MOVE_NAMESPACE::rv<pair> > >::type* = 0
 #endif
 )
- : first(boost::interprocess::forward(const_cast<U&>(u)))
+ : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(const_cast<U&>(u)))
 {}

 #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::interprocess::forward(const_cast<U&>(u))) \
+ : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward(const_cast<U&>(u))) \
 , second(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)) \
 {} \
 //!
@@ -120,32 +120,32 @@
 #include BOOST_PP_LOCAL_ITERATE()
 #endif

- pair& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(pair) p)
+ pair& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(pair) p)
 {
 first = p.first;
 second = p.second;
 return *this;
 }

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

- pair& operator=(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
+ pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
 {
- first = boost::interprocess::move(p.first);
- second = boost::interprocess::move(p.second);
+ first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
+ second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
 return *this;
 }

 template <class D, class S>
- pair& operator=(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
 {
- first = boost::interprocess::move(p.first);
- second = boost::interprocess::move(p.second);
+ first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
+ second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
 return *this;
 }

@@ -194,6 +194,6 @@

} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_PAIR_HPP

Modified: trunk/boost/interprocess/containers/container/detail/pool_common.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/pool_common.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/pool_common.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,7 +15,7 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
+#include "config_begin.hpp"
#include <boost/intrusive/slist.hpp>
#include <new>

@@ -47,6 +47,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP

Modified: trunk/boost/interprocess/containers/container/detail/preprocessor.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/preprocessor.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/preprocessor.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,8 +15,8 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
#error "This file is not needed when perfect forwarding is available"
@@ -81,18 +81,18 @@
#endif

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

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

#define BOOST_CONTAINERS_PP_MEMBER_IT_FORWARD(z, n, data) \
BOOST_PP_CAT(*m_p, n) \
//!

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#else
#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

Modified: trunk/boost/interprocess/containers/container/detail/transform_iterator.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/transform_iterator.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/transform_iterator.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -18,9 +18,9 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <iterator>

namespace boost {
@@ -171,6 +171,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_TRANSFORM_ITERATORS_HPP

Modified: trunk/boost/interprocess/containers/container/detail/tree.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/tree.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/tree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -42,23 +42,23 @@
#ifndef BOOST_CONTAINERS_TREE_HPP
#define BOOST_CONTAINERS_TREE_HPP

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP

-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
#include <boost/pointer_to_other.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/intrusive/rbtree.hpp>

-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
-#include <boost/interprocess/containers/container/detail/node_alloc_holder.hpp>
-#include <boost/interprocess/containers/container/detail/destroyers.hpp>
-#include <boost/interprocess/containers/container/detail/pair.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

#include <utility> //std::pair
@@ -153,7 +153,7 @@

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

@@ -195,8 +195,8 @@

 public:
 template<class Convertible>
- static void construct(node_type *ptr, BOOST_INTERPROCESS_FWD_REF(Convertible) convertible)
- { new(ptr) node_type(boost::interprocess::forward<Convertible>(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)); }
};

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

 public:

@@ -468,14 +468,14 @@
 (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
 }

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

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

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

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

 public:
@@ -620,9 +620,9 @@

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

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

 private:
@@ -683,23 +683,23 @@

 template <class... Args>
 iterator emplace_unique(Args&&... args)
- { return this->emplace_unique_impl(AllocHolder::create_node(boost::interprocess::forward<Args>(args)...)); }
+ { return this->emplace_unique_impl(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...)); }
+ { return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }

 template <class... Args>
 iterator emplace_equal(Args&&... args)
 {
- NodePtr p(AllocHolder::create_node(boost::interprocess::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
 return iterator(this->icont().insert_equal(hint.get(), *p));
 }

@@ -768,14 +768,14 @@
 }

 template<class MovableConvertible>
- iterator insert_unique(const_iterator hint, BOOST_INTERPROCESS_FWD_REF(MovableConvertible) mv)
+ iterator insert_unique(const_iterator hint, BOOST_MOVE_MACRO_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::interprocess::forward<MovableConvertible>(mv), data);
+ return this->insert_unique_commit(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv), data);
 }

 template <class InputIterator>
@@ -801,9 +801,9 @@
 }

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

@@ -814,9 +814,9 @@
 }

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

@@ -1061,6 +1061,6 @@
*/
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //BOOST_CONTAINERS_TREE_HPP

Modified: trunk/boost/interprocess/containers/container/detail/type_traits.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/type_traits.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/type_traits.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -19,7 +19,7 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
+#include "config_begin.hpp"

namespace boost {
namespace container {
@@ -162,5 +162,5 @@

#endif //#ifndef BOOST_CONTAINERS_CONTAINER_DETAIL_TYPE_TRAITS_HPP

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

Modified: trunk/boost/interprocess/containers/container/detail/utilities.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/utilities.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/utilities.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -11,13 +11,13 @@
#ifndef BOOST_CONTAINERS_DETAIL_UTILITIES_HPP
#define BOOST_CONTAINERS_DETAIL_UTILITIES_HPP

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
+#include "config_begin.hpp"
#include <cstdio>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_pointer.hpp>
-#include <boost/interprocess/detail/move.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <algorithm>

namespace boost {
@@ -101,7 +101,7 @@
 : if_c
 < ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value
 ,const T &
- ,BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(T)
+ ,BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(T)
>
{};

@@ -110,6 +110,6 @@
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_UTILITIES_HPP

Modified: trunk/boost/interprocess/containers/container/detail/value_init.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/value_init.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/value_init.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -17,8 +17,8 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

namespace boost {
namespace container {
@@ -38,6 +38,6 @@
} //namespace container {
} //namespace boost {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_VALUE_INIT_HPP

Modified: trunk/boost/interprocess/containers/container/detail/variadic_templates_tools.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/variadic_templates_tools.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/variadic_templates_tools.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,9 +15,9 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include "config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <cstddef> //std::size_t

namespace boost {
@@ -148,6 +148,6 @@

}}} //namespace boost { namespace container { namespace containers_detail {

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP

Modified: trunk/boost/interprocess/containers/container/detail/version_type.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/version_type.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/version_type.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -16,8 +16,10 @@
#ifndef BOOST_CONTAINERS_DETAIL_VERSION_TYPE_HPP
#define BOOST_CONTAINERS_DETAIL_VERSION_TYPE_HPP

-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include "config_begin.hpp"
+
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP

namespace boost{

Modified: trunk/boost/interprocess/containers/container/detail/workaround.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/workaround.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/workaround.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -11,14 +11,14 @@
#ifndef BOOST_CONTAINERS_DETAIL_WORKAROUND_HPP
#define BOOST_CONTAINERS_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
+#include "config_begin.hpp"

#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)\
- && !defined(BOOST_INTERPROCESS_DISABLE_VARIADIC_TMPL)
+ && !defined(BOOST_MOVE_MACRO_DISABLE_VARIADIC_TMPL)
#define BOOST_CONTAINERS_PERFECT_FORWARDING

#endif

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //#ifndef BOOST_CONTAINERS_DETAIL_WORKAROUND_HPP

Modified: trunk/boost/interprocess/containers/container/flat_map.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/flat_map.hpp (original)
+++ trunk/boost/interprocess/containers/container/flat_map.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,18 +15,18 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <utility>
#include <functional>
#include <memory>
#include <stdexcept>
-#include <boost/interprocess/containers/container/detail/flat_tree.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -76,7 +76,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(flat_map)
+ BOOST_MOVE_MACRO_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>,
@@ -183,14 +183,14 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_map(BOOST_INTERPROCESS_RV_REF(flat_map) x)
- : m_flat_tree(boost::interprocess::move(x.m_flat_tree))
+ flat_map(BOOST_MOVE_MACRO_RV_REF(flat_map) x)
+ : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::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_INTERPROCESS_COPY_ASSIGN_REF(flat_map) x)
+ flat_map<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_map) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

 //! Effects: Move constructs a flat_map.
@@ -199,8 +199,8 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_map<Key,T,Pred,Alloc>& operator=(BOOST_INTERPROCESS_RV_REF(flat_map) mx)
- { m_flat_tree = boost::interprocess::move(mx.m_flat_tree); return *this; }
+ 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; }

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -376,13 +376,13 @@
 //! Returns: A reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
- T &operator[](BOOST_INTERPROCESS_RV_REF(key_type) mk)
+ T &operator[](BOOST_MOVE_MACRO_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::interprocess::move(k), boost::interprocess::move(T())));
+ i = insert(i, value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T())));
 return (*i).second;
 }

@@ -445,9 +445,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_INTERPROCESS_RV_REF(value_type) x)
+ std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
 { return force<std::pair<iterator,bool> >(
- m_flat_tree.insert_unique(boost::interprocess::move(force<impl_value_type>(x)))); }
+ m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::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.
@@ -460,10 +460,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_INTERPROCESS_RV_REF(impl_value_type) x)
+ std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
 {
 return force<std::pair<iterator,bool> >
- (m_flat_tree.insert_unique(boost::interprocess::move(x)));
+ (m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
 }

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

 //! Requires: i, j are not iterators into *this.
@@ -538,7 +538,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::interprocess::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::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
@@ -554,7 +554,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::interprocess::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -809,7 +809,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_multimap)
 typedef containers_detail::flat_tree<Key,
 std::pair<Key, T>,
 containers_detail::select1st< std::pair<Key, T> >,
@@ -914,21 +914,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- flat_multimap(BOOST_INTERPROCESS_RV_REF(flat_multimap) x)
- : m_flat_tree(boost::interprocess::move(x.m_flat_tree))
+ flat_multimap(BOOST_MOVE_MACRO_RV_REF(flat_multimap) x)
+ : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::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_INTERPROCESS_COPY_ASSIGN_REF(flat_multimap) x)
+ flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF(flat_multimap) mx)
- { m_flat_tree = boost::interprocess::move(mx.m_flat_tree); return *this; }
+ 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; }

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

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

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -1113,11 +1113,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_INTERPROCESS_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
 {
 return force_copy<iterator>
 (m_flat_tree.insert_equal(force<impl_const_iterator>(position)
- , boost::interprocess::move(x)));
+ , BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
 }

 //! Effects: Inserts a value move constructed from x in the container.
@@ -1131,10 +1131,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_INTERPROCESS_RV_REF(impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
 {
 return force_copy<iterator>(
- m_flat_tree.insert_equal(force<impl_const_iterator>(position), boost::interprocess::move(x)));
+ m_flat_tree.insert_equal(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
 }

 //! Requires: i, j are not iterators into *this.
@@ -1161,7 +1161,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::interprocess::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container.
@@ -1179,7 +1179,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::interprocess::forward<Args>(args)...));
+ (force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
 }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -1406,6 +1406,6 @@

/// @endcond

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif /* BOOST_CONTAINERS_FLAT_MAP_HPP */

Modified: trunk/boost/interprocess/containers/container/flat_set.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/flat_set.hpp (original)
+++ trunk/boost/interprocess/containers/container/flat_set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -15,16 +15,16 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <utility>
#include <functional>
#include <memory>
-#include <boost/interprocess/containers/container/detail/flat_tree.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -65,7 +65,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(flat_set)
+ BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF(flat_set) mx)
- : m_flat_tree(boost::interprocess::move(mx.m_flat_tree))
+ flat_set(BOOST_MOVE_MACRO_RV_REF(flat_set) mx)
+ : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree))
 {}

 //! Effects: Makes *this a copy of x.
 //!
 //! Complexity: Linear in x.size().
- flat_set<T,Pred,Alloc>& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(flat_set) x)
+ flat_set<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF(flat_set) mx)
- { m_flat_tree = boost::interprocess::move(mx.m_flat_tree); return *this; }
+ 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; }

 //! 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::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_INTERPROCESS_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(boost::interprocess::move(x)); }
+ 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)); }

 //! 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::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_INTERPROCESS_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(position, boost::interprocess::move(x)); }
+ 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)); }

 //! 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::interprocess::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -685,7 +685,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
+ BOOST_MOVE_MACRO_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_INTERPROCESS_RV_REF(flat_multiset) x)
- : m_flat_tree(boost::interprocess::move(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<T,Pred,Alloc>& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(flat_multiset) x)
+ flat_multiset<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multiset) x)
 { m_flat_tree = x.m_flat_tree; return *this; }

- flat_multiset<T,Pred,Alloc>& operator=(BOOST_INTERPROCESS_RV_REF(flat_multiset) mx)
- { m_flat_tree = boost::interprocess::move(mx.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; }

 //! 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::interprocess::is_movable::value >::type* =0)
+ 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)
 { 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_INTERPROCESS_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(boost::interprocess::move(x)); }
+ iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ { return m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::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_INTERPROCESS_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(position, boost::interprocess::move(x)); }
+ 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)); }

 //! 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::interprocess::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -1240,6 +1240,6 @@

}}

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif /* BOOST_CONTAINERS_FLAT_SET_HPP */

Modified: trunk/boost/interprocess/containers/container/list.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/list.hpp (original)
+++ trunk/boost/interprocess/containers/container/list.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -47,23 +47,23 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include "detail/config_begin.hpp"
+#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/pointer_to_other.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include <boost/intrusive/list.hpp>
-#include <boost/interprocess/containers/container/detail/node_alloc_holder.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP

#if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
#else
//Preprocessor library to emulate perfect forwarding
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

#include <stdexcept>
@@ -105,7 +105,7 @@

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

 #else //#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -231,7 +231,7 @@

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

 //! Effects: Constructs a list that will use a copy of allocator a
@@ -576,7 +576,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { this->insert(this->cbegin(), u); }
 #endif

@@ -586,8 +586,8 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_front(BOOST_INTERPROCESS_RV_REF(T) x)
- { this->insert(this->cbegin(), boost::interprocess::move(x)); }
+ void push_front(BOOST_MOVE_MACRO_RV_REF(T) x)
+ { this->insert(this->cbegin(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }

 //! Effects: Removes the last element from the list.
 //!
@@ -601,7 +601,7 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { this->insert(this->cend(), u); }

 #endif
@@ -611,8 +611,8 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Amortized constant time.
- void push_back (BOOST_INTERPROCESS_RV_REF(T) x)
- { this->insert(this->cend(), boost::interprocess::move(x)); }
+ void push_back (BOOST_MOVE_MACRO_RV_REF(T) x)
+ { this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }

 //! Effects: Removes the first element from the list.
 //!
@@ -749,7 +749,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- ThisType& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(ThisType) x)
+ ThisType& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(ThisType) x)
 {
 if (this != &x) {
 this->assign(x.begin(), x.end());
@@ -765,7 +765,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- ThisType& operator=(BOOST_INTERPROCESS_RV_REF(ThisType) mx)
+ ThisType& operator=(BOOST_MOVE_MACRO_RV_REF(ThisType) mx)
 {
 this->clear();
 this->swap(mx);
@@ -812,7 +812,7 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

@@ -823,9 +823,9 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- iterator insert(const_iterator p, BOOST_INTERPROCESS_RV_REF(T) x)
+ iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(T) x)
 {
- NodePtr tmp = AllocHolder::create_node(boost::interprocess::move(x));
+ NodePtr tmp = AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
 return iterator(this->icont().insert(p.get(), *tmp));
 }

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

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

 //! Effects: Inserts an object of type T constructed with
@@ -868,7 +868,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::interprocess::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 NodePtr node = d.get();
 d.release();
 return iterator(this->icont().insert(p.get(), *node));
@@ -1399,6 +1399,6 @@

}}

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // BOOST_CONTAINERS_LIST_HPP_

Modified: trunk/boost/interprocess/containers/container/map.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/map.hpp (original)
+++ trunk/boost/interprocess/containers/container/map.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -47,21 +47,21 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <utility>
#include <functional>
#include <memory>
#include <stdexcept>
-#include <boost/interprocess/containers/container/detail/tree.hpp>
-#include <boost/interprocess/containers/container/detail/value_init.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VALUE_INIT_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/pair.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#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

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -99,7 +99,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(map)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(map)
 typedef containers_detail::rbtree<Key,
 std::pair<const Key, T>,
 containers_detail::select1st< std::pair<const Key, T> >,
@@ -193,21 +193,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- map(BOOST_INTERPROCESS_RV_REF(map) x)
- : m_tree(boost::interprocess::move(x.m_tree))
+ map(BOOST_MOVE_MACRO_RV_REF(map) x)
+ : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
 {}

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

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

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -341,27 +341,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::interprocess::move(v.m_t));
- i = insert(i, boost::interprocess::move(val));
+ value_type val(k, BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t));
+ i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
 }
 return (*i).second;
 }

 //! Effects: If there is no key equivalent to x in the map, inserts
- //! value_type(boost::interprocess::move(x), T()) into the map (the key is move-constructed)
+ //! value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x), T()) into the map (the key is move-constructed)
 //!
 //! Returns: A reference to the mapped_type corresponding to x in *this.
 //!
 //! Complexity: Logarithmic.
- T& operator[](BOOST_INTERPROCESS_RV_REF(key_type) mk)
+ T& operator[](BOOST_MOVE_MACRO_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::interprocess::move(k), boost::interprocess::move(T()));
- i = insert(i, boost::interprocess::move(val));
+ value_type val(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T()));
+ i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
 }
 return (*i).second;
 }
@@ -429,8 +429,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_INTERPROCESS_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(boost::interprocess::move(x)); }
+ 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)); }

 //! 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 +440,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_INTERPROCESS_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(boost::interprocess::move(x)); }
+ 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)); }

 //! 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 +451,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return m_tree.insert_unique(boost::interprocess::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::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 +475,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_INTERPROCESS_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(position, boost::interprocess::move(x)); }
+ 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)); }

 //! 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 +487,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_INTERPROCESS_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(position, boost::interprocess::move(x)); }
+ 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)); }

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

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

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -752,7 +752,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(multimap)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(multimap)
 typedef containers_detail::rbtree<Key,
 std::pair<const Key, T>,
 containers_detail::select1st< std::pair<const Key, T> >,
@@ -847,21 +847,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- multimap(BOOST_INTERPROCESS_RV_REF(multimap) x)
- : m_tree(boost::interprocess::move(x.m_tree))
+ multimap(BOOST_MOVE_MACRO_RV_REF(multimap) x)
+ : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
 {}

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

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

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -1009,15 +1009,15 @@
 //! the iterator pointing to the newly inserted element.
 //!
 //! Complexity: Logarithmic.
- iterator insert(BOOST_INTERPROCESS_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(boost::interprocess::move(x)); }
+ iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::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_INTERPROCESS_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(boost::interprocess::move(x)); }
+ iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::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 +1049,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_INTERPROCESS_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(position, boost::interprocess::move(x)); }
+ 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)); }

 //! 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 +1060,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(iterator position, BOOST_INTERPROCESS_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(position, boost::interprocess::move(x)); }
+ 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)); }

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

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... in the container.
@@ -1098,7 +1098,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::interprocess::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -1280,7 +1280,7 @@

}}

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif /* BOOST_CONTAINERS_MAP_HPP */

Modified: trunk/boost/interprocess/containers/container/set.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/set.hpp (original)
+++ trunk/boost/interprocess/containers/container/set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -47,20 +47,20 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP

#include <utility>
#include <functional>
#include <memory>

-#include <boost/interprocess/detail/move.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/tree.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -94,7 +94,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(set)
+ BOOST_MOVE_MACRO_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
@@ -168,21 +168,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- set(BOOST_INTERPROCESS_RV_REF(set) x)
- : m_tree(boost::interprocess::move(x.m_tree))
+ set(BOOST_MOVE_MACRO_RV_REF(set) x)
+ : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
 {}

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

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

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -362,7 +362,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_insert(u); }
 #endif

@@ -374,8 +374,8 @@
 //! points to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return m_tree.insert_unique(boost::interprocess::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::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.
@@ -394,7 +394,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -404,8 +404,8 @@
 //! Returns: An iterator pointing to the element with key equivalent to the key of x.
 //!
 //! Complexity: Logarithmic.
- iterator insert(const_iterator p, BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return m_tree.insert_unique(p, boost::interprocess::move(x)); }
+ 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)); }

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

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

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -652,7 +652,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(multiset)
+ BOOST_MOVE_MACRO_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
@@ -727,21 +727,21 @@
 //! Complexity: Construct.
 //!
 //! Postcondition: x is emptied.
- multiset(BOOST_INTERPROCESS_RV_REF(multiset) x)
- : m_tree(boost::interprocess::move(x.m_tree))
+ multiset(BOOST_MOVE_MACRO_RV_REF(multiset) x)
+ : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
 {}

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

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

 //! Effects: Returns the comparison object out
 //! of which a was constructed.
@@ -917,7 +917,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::interprocess::is_movable::value >::type* =0)
+ 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)
 { return priv_insert(u); }
 #endif

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

 //! Effects: Inserts a copy of x in the container.
 //! p is a hint pointing to where the insert should start to search.
@@ -947,7 +947,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_insert(position, u); }
 #endif

@@ -959,8 +959,8 @@
 //!
 //! Complexity: Logarithmic in general, but amortized constant if t
 //! is inserted right before p.
- iterator insert(const_iterator p, BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return m_tree.insert_equal(p, boost::interprocess::move(x)); }
+ 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)); }

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

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)...
@@ -992,7 +992,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::interprocess::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }

 #else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING

@@ -1181,7 +1181,7 @@

}}

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif /* BOOST_CONTAINERS_SET_HPP */

Modified: trunk/boost/interprocess/containers/container/slist.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/slist.hpp (original)
+++ trunk/boost/interprocess/containers/container/slist.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -47,24 +47,24 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
+#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
#include <boost/pointer_to_other.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/interprocess/containers/container/detail/node_alloc_holder.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_NODE_ALLOC_HOLDER_HPP
#include <boost/intrusive/slist.hpp>

#if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
//Preprocessor library to emulate perfect forwarding
#else
-#include <boost/interprocess/containers/container/detail/preprocessor.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif

#include <stdexcept>
@@ -105,7 +105,7 @@

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

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

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

 //! Effects: Makes *this contain the same elements as x.
@@ -416,7 +416,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- slist& operator= (BOOST_INTERPROCESS_COPY_ASSIGN_REF(slist) x)
+ slist& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(slist) x)
 {
 if (&x != this){
 this->assign(x.begin(), x.end());
@@ -432,7 +432,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- slist& operator= (BOOST_INTERPROCESS_RV_REF(slist) mx)
+ slist& operator= (BOOST_MOVE_MACRO_RV_REF(slist) mx)
 {
 if (&mx != this){
 this->clear();
@@ -635,7 +635,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_push_front(u); }
 #endif

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

 //! Effects: Removes the first element from the list.
 //!
@@ -697,7 +697,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert_after(position, u); }
 #endif

@@ -714,8 +714,8 @@
 //!
 //! Note: Does not affect the validity of iterators and references of
 //! previous values.
- iterator insert_after(const_iterator prev_pos, BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(boost::interprocess::move(x)))); }
+ 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)))); }

 //! Requires: prev_pos must be a valid iterator of *this.
 //!
@@ -765,7 +765,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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

@@ -776,8 +776,8 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Linear to the elements before p.
- iterator insert(const_iterator p, BOOST_INTERPROCESS_RV_REF(value_type) x)
- { return this->insert_after(previous(p), boost::interprocess::move(x)); }
+ 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)); }

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

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... before p
@@ -824,7 +824,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::interprocess::forward<Args>(args)...); }
+ { return this->emplace_after(this->previous(p), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }

 //! Effects: Inserts an object of type T constructed with
 //! std::forward<Args>(args)... after prev
@@ -837,7 +837,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::interprocess::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 NodePtr node = d.get();
 d.release();
 return iterator(this->icont().insert_after(prev.get(), *node));
@@ -1370,7 +1370,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, n, x); }
+ { this->priv_create_and_insert_nodes(prev, (std::size_t)n, x); }

 void priv_fill_assign(size_type n, const T& val)
 {
@@ -1412,7 +1412,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, n, x); }
+ { this->priv_create_and_insert_nodes(prev_pos, (std::size_t)n, x); }

 template <class InIter>
 void priv_insert_after_range_dispatch(const_iterator prev_pos, InIter first, InIter last, containers_detail::false_)
@@ -1559,6 +1559,6 @@

///@endcond

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif /* BOOST_CONTAINERS_SLIST_HPP */

Modified: trunk/boost/interprocess/containers/container/stable_vector.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/stable_vector.hpp (original)
+++ trunk/boost/interprocess/containers/container/stable_vector.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -22,18 +22,18 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include <boost/mpl/bool.hpp>
#include <boost/mpl/not.hpp>
#include <boost/noncopyable.hpp>
#include <boost/type_traits/is_integral.hpp>
-#include <boost/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/containers/container/detail/multiallocation_chain.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/iterators.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MULTIALLOCATION_CHAIN_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
#include <boost/pointer_to_other.hpp>
#include <boost/get_pointer.hpp>

@@ -46,7 +46,7 @@
#define STABLE_VECTOR_USE_CONTAINERS_VECTOR

#if defined (STABLE_VECTOR_USE_CONTAINERS_VECTOR)
-#include <boost/interprocess/containers/container/vector.hpp>
+#include INCLUDE_BOOST_CONTAINER_VECTOR_HPP
#else
#include <vector>
#endif //STABLE_VECTOR_USE_CONTAINERS_VECTOR
@@ -140,7 +140,7 @@

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

 #else //BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -454,7 +454,7 @@

 ///@cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(stable_vector)
+ BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(stable_vector)
 static const size_type ExtraPointers = 3;
 typedef typename stable_vector_detail::
 select_multiallocation_chain
@@ -508,7 +508,7 @@
 cod.release();
 }

- stable_vector(BOOST_INTERPROCESS_RV_REF(stable_vector) x)
+ stable_vector(BOOST_MOVE_MACRO_RV_REF(stable_vector) x)
 : internal_data(x.get_al()),impl(x.get_al())
 { this->swap(x); }

@@ -518,7 +518,7 @@
 clear_pool();
 }

- stable_vector& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(stable_vector) x)
+ stable_vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(stable_vector) x)
 {
 STABLE_VECTOR_CHECK_INVARIANT;
 if (this != &x) {
@@ -527,7 +527,7 @@
 return *this;
 }

- stable_vector& operator=(BOOST_INTERPROCESS_RV_REF(stable_vector) x)
+ stable_vector& operator=(BOOST_MOVE_MACRO_RV_REF(stable_vector) x)
 {
 if (&x != this){
 this->swap(x);
@@ -676,12 +676,12 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_push_back(u); }
 #endif

- void push_back(BOOST_INTERPROCESS_RV_REF(T) t)
- { this->insert(end(), boost::interprocess::move(t)); }
+ void push_back(BOOST_MOVE_MACRO_RV_REF(T) t)
+ { this->insert(end(), BOOST_CONTAINER_MOVE_NAMESPACE::move(t)); }

 void pop_back()
 { this->erase(this->end()-1); }
@@ -693,14 +693,14 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

- iterator insert(const_iterator position, BOOST_INTERPROCESS_RV_REF(T) x)
+ iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x)
 {
 typedef repeat_iterator<T, difference_type> repeat_it;
- typedef boost::interprocess::move_iterator<repeat_it> repeat_move_it;
+ typedef BOOST_CONTAINER_MOVE_NAMESPACE::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
@@ -736,7 +736,7 @@
 {
 typedef emplace_functor<node_type_t, Args...> EmplaceFunctor;
 typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
- EmplaceFunctor &&ef = EmplaceFunctor(boost::interprocess::forward<Args>(args)...);
+ EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
 }

@@ -756,7 +756,7 @@
 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::interprocess::forward<Args>(args)...);
+ EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 this->insert(position, EmplaceIterator(ef), EmplaceIterator());
 return iterator(this->begin() + pos_n);
 }
@@ -870,7 +870,7 @@
 void_ptr &p2 = impl.back();
 multiallocation_chain holder;
 holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
- get_al().deallocate_individual(boost::interprocess::move(holder));
+ get_al().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(holder));
 p1 = p2 = 0;
 this->internal_data.pool_size = 0;
 }
@@ -900,7 +900,7 @@
 void_ptr &p2 = impl.back();
 multiallocation_chain holder;
 holder.incorporate_after(holder.before_begin(), p1, p2, internal_data.pool_size);
- BOOST_STATIC_ASSERT((::boost::interprocess::is_movable<multiallocation_chain>::value == true));
+ BOOST_STATIC_ASSERT((::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<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;
@@ -1169,7 +1169,7 @@
 }
 catch(...){
 get_al().deallocate_one(p);
- get_al().deallocate_many(boost::interprocess::move(mem));
+ get_al().deallocate_many(BOOST_CONTAINER_MOVE_NAMESPACE::move(mem));
 impl.erase(it+i, it+n);
 this->align_nodes(it+i,get_last_align());
 throw;
@@ -1324,6 +1324,6 @@

}}

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif //BOOST_CONTAINER_STABLE_VECTOR_HPP

Modified: trunk/boost/interprocess/containers/container/string.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/string.hpp (original)
+++ trunk/boost/interprocess/containers/container/string.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -27,18 +27,18 @@
#ifndef BOOST_CONTAINERS_STRING_HPP
#define BOOST_CONTAINERS_STRING_HPP

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/iterators.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
-#include <boost/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/containers/container/detail/allocation_type.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
+#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/static_assert.hpp>

#include <functional>
@@ -55,7 +55,7 @@
#include <locale>
#include <cstddef>
#include <climits>
-#include <boost/interprocess/containers/container/detail/type_traits.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>

@@ -83,7 +83,7 @@
class basic_string_base
{
 basic_string_base();
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)
+ BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)

 public:
 typedef A allocator_type;
@@ -104,7 +104,7 @@
 this->allocate_initial_block(n);
 }

- basic_string_base(BOOST_INTERPROCESS_RV_REF(basic_string_base) b)
+ basic_string_base(BOOST_MOVE_MACRO_RV_REF(basic_string_base) b)
 : members_(b.members_)
 {
 init();
@@ -445,7 +445,7 @@
{
 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(basic_string)
+ BOOST_MOVE_MACRO_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;

@@ -551,8 +551,8 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- basic_string(BOOST_INTERPROCESS_RV_REF(basic_string) s)
- : base_t(boost::interprocess::move((base_t&)s))
+ basic_string(BOOST_MOVE_MACRO_RV_REF(basic_string) s)
+ : base_t(BOOST_CONTAINER_MOVE_NAMESPACE::move((base_t&)s))
 {}

 //! Effects: Constructs a basic_string taking the allocator as parameter,
@@ -618,7 +618,7 @@
 //! Postcondition: x == *this.
 //!
 //! Complexity: Linear to the elements x contains.
- basic_string& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(basic_string) s)
+ basic_string& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(basic_string) s)
 {
 if (&s != this)
 this->assign(s.begin(), s.end());
@@ -630,7 +630,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Constant.
- basic_string& operator=(BOOST_INTERPROCESS_RV_REF(basic_string) ms)
+ basic_string& operator=(BOOST_MOVE_MACRO_RV_REF(basic_string) ms)
 {
 basic_string &s = ms;
 if (&s != this){
@@ -947,7 +947,7 @@
 { return this->operator=(s); }

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

 //! Effects: Assigns the range [pos, pos + n) from s to *this.
@@ -1916,19 +1916,19 @@
}

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

template <class CharT, class Traits, class A> inline
-BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
 operator+(const basic_string<CharT,Traits,A>& x,
- BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_MOVE_MACRO_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);
@@ -1949,12 +1949,12 @@
}

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

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

template <class CharT, class Traits, class A> inline
-BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(CharT c,
- BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_MOVE_MACRO_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);
@@ -1994,12 +1994,12 @@
}

template <class CharT, class Traits, class A>
-BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+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
 , const CharT* s)
{
 mx += s;
- return boost::interprocess::move(mx);
+ return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
}

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

template <class CharT, class Traits, class A>
-BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+( BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+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
 , const CharT c)
{
 mx += c;
- return boost::interprocess::move(mx);
+ return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
}

// Operator== and operator!=
@@ -2273,7 +2273,6 @@
 std::basic_streambuf<CharT, Traits>* buf = is.rdbuf();
 s.clear();

- int c1;
 while (nread < s.max_size()) {
 int c1 = buf->sbumpc();
 if (Traits::eq_int_type(c1, Traits::eof())) {
@@ -2327,6 +2326,6 @@

/// @endcond

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // BOOST_CONTAINERS_STRING_HPP

Modified: trunk/boost/interprocess/containers/container/vector.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/vector.hpp (original)
+++ trunk/boost/interprocess/containers/container/vector.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -43,9 +43,9 @@
# pragma once
#endif

-#include <boost/interprocess/containers/container/detail/config_begin.hpp>
-#include <boost/interprocess/containers/container/detail/workaround.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
+#include "detail/config_begin.hpp"
+#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP

#include <cstddef>
#include <memory>
@@ -59,17 +59,17 @@
#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/interprocess/containers/container/detail/version_type.hpp>
-#include <boost/interprocess/containers/container/detail/allocation_type.hpp>
-#include <boost/interprocess/containers/container/detail/utilities.hpp>
-#include <boost/interprocess/containers/container/detail/iterators.hpp>
-#include <boost/interprocess/containers/container/detail/algorithms.hpp>
-#include <boost/interprocess/containers/container/detail/destroyers.hpp>
-#include <boost/interprocess/containers/container/container_fwd.hpp>
-#include <boost/interprocess/detail/move.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ITERATORS_HPP
+#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/pointer_to_other.hpp>
-#include <boost/interprocess/containers/container/detail/mpl.hpp>
-#include <boost/interprocess/containers/container/detail/advanced_insert_int.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
+#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP

namespace boost {
namespace container {
@@ -439,7 +439,7 @@

 /// @cond
 private:
- BOOST_COPYABLE_AND_MOVABLE(vector)
+ BOOST_MOVE_MACRO_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;

@@ -449,7 +449,7 @@

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

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

@@ -808,8 +808,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::interprocess::move_iterator<T*>, T*>
- proxy(::boost::interprocess::make_move_iterator(dummy_it), ::boost::interprocess::make_move_iterator(dummy_it));
+ 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));
 //Backwards (and possibly forward) expansion
 if(ret.second){
 #ifdef BOOST_CONTAINERS_VECTOR_ALLOC_STATS
@@ -846,7 +846,7 @@
 //! Throws: If memory allocation throws or T's copy constructor throws.
 //!
 //! Complexity: Linear to the number of elements in x.
- vector& operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(vector) x)
+ vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(vector) x)
 {
 if (&x != this){
 this->assign(x.members_.m_start, x.members_.m_start + x.members_.m_size);
@@ -862,7 +862,7 @@
 //! Throws: If allocator_type's copy constructor throws.
 //!
 //! Complexity: Linear.
- vector& operator=(BOOST_INTERPROCESS_RV_REF(vector) x)
+ vector& operator=(BOOST_MOVE_MACRO_RV_REF(vector) x)
 {
 if (&x != this){
 this->swap(x);
@@ -907,7 +907,7 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return priv_push_back(u); }
 #endif

@@ -917,15 +917,15 @@
 //! Throws: If memory allocation throws.
 //!
 //! Complexity: Amortized constant time.
- void push_back(BOOST_INTERPROCESS_RV_REF(T) x)
+ void push_back(BOOST_MOVE_MACRO_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::interprocess::move(x));
+ new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
 ++this->members_.m_size;
 }
 else{
- this->insert(this->cend(), boost::interprocess::move(x));
+ this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
 }
 }

@@ -943,12 +943,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::interprocess::forward<Args>(args)...);
+ new((void*)(back_pos))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 ++this->members_.m_size;
 }
 else{
 typedef containers_detail::advanced_insert_aux_emplace<T, T*, Args...> type;
- type &&proxy = type(boost::interprocess::forward<Args>(args)...);
+ type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 priv_range_insert(back_pos, 1, proxy);
 }
 }
@@ -968,7 +968,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::interprocess::forward<Args>(args)...);
+ type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
 priv_range_insert(position.get_ptr(), 1, proxy);
 return iterator(this->members_.m_start + pos_n);
 }
@@ -1066,7 +1066,7 @@
 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::interprocess::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_CONTAINER_MOVE_NAMESPACE::is_movable::value >::type* =0)
 { return this->priv_insert(position, u); }
 #endif

@@ -1078,7 +1078,7 @@
 //!
 //! Complexity: If position is end(), amortized constant time
 //! Linear time otherwise.
- iterator insert(const_iterator position, BOOST_INTERPROCESS_RV_REF(T) x)
+ 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();
@@ -1137,7 +1137,7 @@
 {
 T *pos = containers_detail::get_pointer(position.get_ptr());
 T *beg = containers_detail::get_pointer(this->members_.m_start);
- boost::interprocess::move(pos + 1, beg + this->members_.m_size, pos);
+ BOOST_CONTAINER_MOVE_NAMESPACE::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);
@@ -1153,7 +1153,7 @@
 {
 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::interprocess::move
+ T* ptr = containers_detail::get_pointer(BOOST_CONTAINER_MOVE_NAMESPACE::move
 (containers_detail::get_pointer(last.get_ptr())
 ,end_pos
 ,containers_detail::get_pointer(first.get_ptr())
@@ -1360,10 +1360,10 @@
 if (elems_after > n){
 //New elements can be just copied.
 //Move to uninitialized memory last objects
- ::boost::interprocess::uninitialized_move(old_finish - n, old_finish, old_finish);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_finish - n, old_finish, old_finish);
 this->members_.m_size += n;
 //Copy previous to last objects to the initialized end
- boost::interprocess::move_backward(pos, old_finish - n, old_finish);
+ BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, old_finish - n, old_finish);
 //Insert new objects in the pos
 interf.copy_all_to(pos);
 }
@@ -1373,7 +1373,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::interprocess::uninitialized_move
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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
@@ -1395,7 +1395,7 @@
 //the start of the new buffer
 T *old_buffer = containers_detail::get_pointer(this->members_.m_start);
 if(old_buffer){
- new_finish = ::boost::interprocess::uninitialized_move
+ new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
 (containers_detail::get_pointer(this->members_.m_start), pos, old_finish = new_finish);
 constructed_values_destroyer.increment_size(new_finish - old_finish);
 }
@@ -1406,7 +1406,7 @@
 //Initialize from the rest of the old buffer,
 //starting from previous point
 if(old_buffer){
- new_finish = ::boost::interprocess::uninitialized_move
+ new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
 (pos, old_buffer + this->members_.m_size, new_finish);
 //Destroy and deallocate old elements
 //If there is allocated memory, destroy and deallocate
@@ -1447,7 +1447,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::interprocess::uninitialized_move(old_start, pos, new_start);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1465,7 +1465,7 @@
 //|___________|__________|_________|________________________|
 //
 //Now initialize the rest of memory with the last old values
- ::boost::interprocess::uninitialized_move
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1492,13 +1492,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::interprocess::uninitialized_move(pos, pos + raw_gap, new_start + elemsbefore + n);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::move(pos + raw_gap, old_finish, old_start);
+ T *to_destroy = BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1557,13 +1557,13 @@
 //
 //Copy the first part of old_begin to raw_mem
 T *start_n = old_start + difference_type(s_before);
- ::boost::interprocess::uninitialized_move(old_start, start_n, new_start);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::move(start_n, pos, old_start);
+ T* next = BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
 if(do_after){
 //Now copy the new_beg elements
 interf.copy_some_and_update(next, s_before, true);
@@ -1573,7 +1573,7 @@
 interf.copy_all_to(next);
 T* move_start = next + n;
 //Now displace old_end elements
- T* move_end = boost::interprocess::move(pos, old_finish, move_start);
+ T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1609,7 +1609,7 @@
 //|___________|_____|_________|__________________________|
 //
 //First copy whole old_begin and part of new to raw_mem
- ::boost::interprocess::uninitialized_move(old_start, pos, new_start);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
 this->members_.m_size = elemsbefore;

 const size_type mid_n = difference_type(s_before) - elemsbefore;
@@ -1628,7 +1628,7 @@
 interf.copy_all_to(old_start);
 T* move_start = old_start + (n-mid_n);
 //Displace old_end
- T* move_end = boost::interprocess::move(pos, old_finish, move_start);
+ T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::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;
@@ -1679,10 +1679,10 @@
 //
 //First copy the part of old_end raw_mem
 T* finish_n = old_finish - difference_type(n_after);
- ::boost::interprocess::uninitialized_move(finish_n, old_finish, old_finish);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::move_backward(pos, finish_n, old_finish);
+ BOOST_CONTAINER_MOVE_NAMESPACE::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);
@@ -1705,7 +1705,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::interprocess::uninitialized_move(pos, old_finish, old_finish + mid_last_dist);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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);
@@ -1718,7 +1718,7 @@
 void priv_range_insert(const_iterator pos, InIt first, InIt last, std::input_iterator_tag)
 {
 for(;first != last; ++first){
- this->insert(pos, boost::interprocess::move(value_type(*first)));
+ this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
 }
 }

@@ -1789,14 +1789,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::interprocess::uninitialized_copy_or_move(mid, last, end);
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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::interprocess::uninitialized_copy_or_move(first, last, containers_detail::get_pointer(ret.first));
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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){
@@ -1826,7 +1826,7 @@
 FwdIt mid = first;
 std::advance(mid, first_count);
 // iG std::uninitialized_copy(first, mid, containers_detail::get_pointer(ret.first));
- ::boost::interprocess::uninitialized_copy_or_move(first, mid, containers_detail::get_pointer(ret.first));
+ ::BOOST_CONTAINER_MOVE_NAMESPACE::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"
@@ -1955,7 +1955,7 @@

/// @endcond

-#include <boost/interprocess/containers/container/detail/config_end.hpp>
+#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP

#endif // #ifndef BOOST_CONTAINERS_CONTAINERS_VECTOR_HPP

Modified: trunk/boost/interprocess/detail/atomic.hpp
==============================================================================
--- trunk/boost/interprocess/detail/atomic.hpp (original)
+++ trunk/boost/interprocess/detail/atomic.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -22,7 +22,7 @@
namespace interprocess{
namespace detail{

-//! Atomically increment an apr_uint32_t by 1
+//! Atomically increment an boost::uint32_t by 1
//! "mem": pointer to the object
//! Returns the old value pointed to by mem
inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem);

Modified: trunk/boost/interprocess/detail/managed_memory_impl.hpp
==============================================================================
--- trunk/boost/interprocess/detail/managed_memory_impl.hpp (original)
+++ trunk/boost/interprocess/detail/managed_memory_impl.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -519,7 +519,16 @@
 //!function call. If the functor throws, this function throws.
 template <class Func>
 void atomic_func(Func &f)
- { mp_header->atomic_func(f); }
+ { mp_header->atomic_func(f); }
+
+ //!Tries to call a functor guaranteeing that no new construction, search or
+ //!destruction will be executed by any process while executing the object
+ //!function call. If the atomic function can't be immediatelly executed
+ //!because the internal mutex is already locked, returns false.
+ //!If the functor throws, this function throws.
+ template <class Func>
+ bool try_atomic_func(Func &f)
+ { return mp_header->try_atomic_func(f); }

 //!Destroys a named memory object or array.
 //!

Modified: trunk/boost/interprocess/detail/move.hpp
==============================================================================
--- trunk/boost/interprocess/detail/move.hpp (original)
+++ trunk/boost/interprocess/detail/move.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -19,8 +19,8 @@

//! \file

-#ifndef BOOST_MOVE_HPP
-#define BOOST_MOVE_HPP
+#ifndef BOOST_MOVE_DETAIL_MOVE_HPP
+#define BOOST_MOVE_DETAIL_MOVE_HPP

#include <boost/config.hpp>
#include <algorithm> //copy, copy_backward
@@ -34,8 +34,24 @@

/// @cond

+#define BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+
+#ifdef BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+
+#define INTERPROCESS_NAMESPACE_BEGIN namespace interprocess {
+#define INTERPROCESS_NAMESPACE_END }// namespace interprocess {
+#define BOOST_MOVE_NAMESPACE boost::interprocess
+
+#else //BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+
+#define INTERPROCESS_NAMESPACE_BEGIN
+#define INTERPROCESS_NAMESPACE_END
+#define BOOST_MOVE_NAMESPACE boost
+
+#endif //BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+
namespace boost {
-namespace interprocess {
+INTERPROCESS_NAMESPACE_BEGIN
namespace move_detail {

template <class T>
@@ -56,18 +72,18 @@
 enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
};

-} //namespace interprocess {
} //namespace move_detail {
+INTERPROCESS_NAMESPACE_END
} //namespace boost {

/// @endcond

#if !defined(BOOST_HAS_RVALUE_REFS) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)

-//#define BOOST_MOVE_ASSIGN_FROM_NON_CONST_RVALUE
+//#define BOOST_MOVE_MACRO_MOVE_ASSIGN_FROM_NON_CONST_RVALUE

namespace boost {
-namespace interprocess {
+INTERPROCESS_NAMESPACE_BEGIN

//////////////////////////////////////////////////////////////////////////////
//
@@ -156,121 +172,121 @@
//////////////////////////////////////////////////////////////////////////////

template <class T>
-typename enable_if< ::boost::interprocess::move_detail::is_rv<T>, T &>::type
+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::interprocess::move_detail::is_rv<T>, const T &>::type
+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;
}

-#define BOOST_INTERPROCESS_RV_REF(TYPE)\
- ::boost::interprocess::rv< TYPE >& \
+#define BOOST_MOVE_MACRO_RV_REF(TYPE)\
+ ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
//

-#define BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- ::boost::interprocess::rv< TYPE<ARG1, ARG2> >& \
+#define BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
//

-#define BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- ::boost::interprocess::rv< TYPE<ARG1, ARG2, ARG3> >& \
+#define BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
//

-#ifdef BOOST_MOVE_ASSIGN_FROM_NON_CONST_RVALUE
+#ifdef BOOST_MOVE_MACRO_MOVE_ASSIGN_FROM_NON_CONST_RVALUE

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE)\
- const ::boost::interprocess::rv< TYPE >& \
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE)\
+ const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
//

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const ::boost::interprocess::rv< TYPE<ARG1, ARG2> >& \
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
//

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const ::boost::interprocess::rv< TYPE<ARG1, ARG2, ARG3> >& \
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
//

-#else //BOOST_MOVE_ASSIGN_FROM_NON_CONST_RVALUE
+#else //BOOST_MOVE_MACRO_MOVE_ASSIGN_FROM_NON_CONST_RVALUE

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE)\
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE)\
 const TYPE & \
//

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
 const TYPE< ARG1, ARG2 >& \
//

-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
 const TYPE< ARG1, ARG2, ARG3 > & \
//

#endif

-#define BOOST_INTERPROCESS_FWD_REF(TYPE)\
+#define BOOST_MOVE_MACRO_FWD_REF(TYPE)\
 const TYPE & \
//

-#define BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(TYPE)\
- const ::boost::interprocess::rv< TYPE >& \
+#define BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE)\
+ const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
//

//////////////////////////////////////////////////////////////////////////////
//
-// BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE
+// BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE
//
//////////////////////////////////////////////////////////////////////////////
-#define BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
+#define BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
 private:\
 TYPE(TYPE &);\
 TYPE& operator=(TYPE &);\
 public:\
- operator ::boost::interprocess::rv<TYPE>&() \
- { return *reinterpret_cast< ::boost::interprocess::rv<TYPE>* >(this); }\
- operator const ::boost::interprocess::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::boost::interprocess::rv<TYPE>* >(this); }\
+ 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); }\
 private:\
//

//////////////////////////////////////////////////////////////////////////////
//
-// BOOST_COPYABLE_AND_MOVABLE
+// BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE
//
//////////////////////////////////////////////////////////////////////////////

-#ifdef BOOST_MOVE_ASSIGN_FROM_NON_CONST_RVALUE
+#ifdef BOOST_MOVE_MACRO_MOVE_ASSIGN_FROM_NON_CONST_RVALUE

-#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+#define BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE)\
 public:\
 TYPE& operator=(TYPE &t)\
- { this->operator=(static_cast<const ::boost::interprocess::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
+ { this->operator=(static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
 public:\
- operator ::boost::interprocess::rv<TYPE>&() \
- { return *reinterpret_cast< ::boost::interprocess::rv<TYPE>* >(this); }\
- operator const ::boost::interprocess::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::boost::interprocess::rv<TYPE>* >(this); }\
+ 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); }\
 private:\
//

-#else //#ifdef BOOST_MOVE_ASSIGN_FROM_NON_CONST_RVALUE
+#else //#ifdef BOOST_MOVE_MACRO_MOVE_ASSIGN_FROM_NON_CONST_RVALUE

-#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+#define BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE)\
 public:\
- operator ::boost::interprocess::rv<TYPE>&() \
- { return *reinterpret_cast< ::boost::interprocess::rv<TYPE>* >(this); }\
- operator const ::boost::interprocess::rv<TYPE>&() const \
- { return *reinterpret_cast<const ::boost::interprocess::rv<TYPE>* >(this); }\
+ 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); }\
 private:\
//

#endif

-} //namespace interprocess {
+INTERPROCESS_NAMESPACE_END
} //namespace boost

#else //BOOST_HAS_RVALUE_REFS
@@ -278,7 +294,7 @@
#include <boost/type_traits/remove_reference.hpp>

namespace boost {
-namespace interprocess {
+INTERPROCESS_NAMESPACE_BEGIN

/// @cond

@@ -306,9 +322,9 @@
//////////////////////////////////////////////////////////////////////////////

//! For compilers with rvalue references, this traits class returns true
-//! if BOOST_ENABLE_MOVE_EMULATION is activated.
+//! if BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION is activated.
//!
-//! For other compilers returns true if T is convertible to ::boost::interprocess::rv<T>&
+//! For other compilers returns true if T is convertible to ::BOOST_MOVE_NAMESPACE::rv<T>&
template<class T>
class is_movable
 : public ::boost::mpl::bool_<move_detail::internal_member_value_traits<T>::value>
@@ -333,7 +349,7 @@
#if defined(BOOST_MOVE_DOXYGEN_INVOKED)
//! This function provides a way to convert a reference into a rvalue reference
//! in compilers with rvalue reference. For other compilers converts T & into
-//! ::boost::interprocess::rv<T> & so that move emulation is activated.
+//! ::BOOST_MOVE_NAMESPACE::rv<T> & so that move emulation is activated.
template <class T> inline
rvalue_reference move (input_reference);
#else
@@ -357,7 +373,7 @@
//! For compilers with rvalue references this function provides perfect forwarding.
//!
//! Otherwise:
-//! * If input_reference binds to const ::boost::interprocess::rv<T> & then it output_reference is
+//! * If input_reference binds to const ::BOOST_MOVE_NAMESPACE::rv<T> & then it output_reference is
//! ::boost::rev<T> &
//!
//! * Else, input_reference is equal to output_reference is equal to input_reference.
@@ -370,13 +386,13 @@

//////////////////////////////////////////////////////////////////////////////
//
-// BOOST_ENABLE_MOVE_EMULATION
+// BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION
//
//////////////////////////////////////////////////////////////////////////////

///@cond

-#define BOOST_ENABLE_MOVE_EMULATION(TYPE)\
+#define BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION(TYPE)\
 typedef int boost_move_emulation_t;
\
//
@@ -386,7 +402,7 @@
//! This macro marks a type as movable but not copyable, disabling copy construction
//! and assignment. The user will need to write a move constructor/assignment as explained
//! in the documentation to fully write a movable but not copyable class.
-#define BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
+#define BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
 public:\
 typedef int boost_move_emulation_t;\
 private:\
@@ -397,17 +413,17 @@
//! This macro marks a type as copyable and movable.
//! 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)\
+#define BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE)\
 typedef int boost_move_emulation_t;
//

/// @cond

-#define BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+#define BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
 TYPE<ARG1, ARG2> && \
//

-#define BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+#define BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
 TYPE<ARG1, ARG2, ARG3> && \
//

@@ -415,24 +431,24 @@

//!This macro is used to achieve portable syntax in move
//!constructors and assignments for classes marked as
-//!BOOST_COPYABLE_AND_MOVABLE or BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE
-#define BOOST_INTERPROCESS_RV_REF(TYPE)\
+//!BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE or BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE
+#define BOOST_MOVE_MACRO_RV_REF(TYPE)\
 TYPE && \
//

//!This macro is used to achieve portable syntax in copy
-//!assignment for classes marked as BOOST_COPYABLE_AND_MOVABLE.
-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE)\
+//!assignment for classes marked as BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE.
+#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE)\
 const TYPE & \
//

/// @cond

-#define BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+#define BOOST_MOVE_MACRO_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
 const TYPE<ARG1, ARG2> & \
//

-#define BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+#define BOOST_MOVE_MACRO_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
 TYPE<ARG1, ARG2, ARG3>& \
//

@@ -440,21 +456,21 @@

//! This macro is used to implement portable perfect forwarding
//! as explained in the documentation.
-#define BOOST_INTERPROCESS_FWD_REF(TYPE)\
+#define BOOST_MOVE_MACRO_FWD_REF(TYPE)\
 TYPE && \
//

-#define BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(TYPE)\
+#define BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE)\
 const TYPE & \
//

-} //namespace interprocess {
+INTERPROCESS_NAMESPACE_END
} //namespace boost {

#endif //BOOST_HAS_RVALUE_REFS

namespace boost {
-namespace interprocess {
+INTERPROCESS_NAMESPACE_BEGIN

//////////////////////////////////////////////////////////////////////////////
//
@@ -477,8 +493,8 @@
 typedef value_type && reference;
 #else
 typedef typename ::boost::mpl::if_
- < ::boost::interprocess::is_movable<value_type>
- , ::boost::interprocess::rv<value_type>&
+ < ::BOOST_MOVE_NAMESPACE::is_movable<value_type>
+ , ::BOOST_MOVE_NAMESPACE::rv<value_type>&
 , value_type & >::type reference;
 #endif
 typedef It pointer;
@@ -505,7 +521,7 @@
 #if defined(BOOST_HAS_RVALUE_REFS)
 return *m_it;
 #else
- return ::boost::interprocess::move(*m_it);
+ return ::BOOST_MOVE_NAMESPACE::move(*m_it);
 #endif
 }

@@ -541,7 +557,7 @@
 #if defined(BOOST_HAS_RVALUE_REFS)
 return m_it[n];
 #else
- return ::boost::interprocess::move(m_it[n]);
+ return ::BOOST_MOVE_NAMESPACE::move(m_it[n]);
 #endif
 }

@@ -584,7 +600,7 @@
};

template <class I>
-struct is_move_iterator< ::boost::interprocess::move_iterator >
+struct is_move_iterator< ::BOOST_MOVE_NAMESPACE::move_iterator >
 : public ::boost::mpl::bool_<true>
{
};
@@ -624,7 +640,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::interprocess::move(x)); return *this; }
+ { container_m->push_back(BOOST_MOVE_NAMESPACE::move(x)); return *this; }

 back_move_insert_iterator& operator*() { return *this; }
 back_move_insert_iterator& operator++() { return *this; }
@@ -659,7 +675,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::interprocess::move(x)); return *this; }
+ { container_m->push_front(BOOST_MOVE_NAMESPACE::move(x)); return *this; }

 front_move_insert_iterator& operator*() { return *this; }
 front_move_insert_iterator& operator++() { return *this; }
@@ -695,7 +711,7 @@

 move_insert_iterator& operator=(typename C::reference x)
 {
- pos_ = container_m->insert(pos_, ::boost::interprocess::move(x));
+ pos_ = container_m->insert(pos_, ::BOOST_MOVE_NAMESPACE::move(x));
 ++pos_;
 return *this;
 }
@@ -722,7 +738,7 @@

//! Effects: Moves elements in the range [first,last) into the range [result,result + (last -
//! first)) starting from first and proceeding to last. For each non-negative integer n < (last-first),
-//! performs *(result + n) = ::boost::interprocess::move (*(first + n)).
+//! performs *(result + n) = ::BOOST_MOVE_NAMESPACE::move (*(first + n)).
//!
//! Effects: result + (last - first).
//!
@@ -734,7 +750,7 @@
O move(I f, I l, O result)
{
 while (f != l) {
- *result = ::boost::interprocess::move(*f);
+ *result = ::BOOST_MOVE_NAMESPACE::move(*f);
 ++f; ++result;
 }
 return result;
@@ -749,7 +765,7 @@
//! Effects: Moves elements in the range [first,last) into the range
//! [result - (last-first),result) starting from last - 1 and proceeding to
//! first. For each positive integer n <= (last - first),
-//! performs *(result - n) = ::boost::interprocess::move(*(last - n)).
+//! performs *(result - n) = ::BOOST_MOVE_NAMESPACE::move(*(last - n)).
//!
//! Requires: result shall not be in the range [first,last).
//!
@@ -762,7 +778,7 @@
{
 while (f != l) {
 --l; --result;
- *result = ::boost::interprocess::move(*l);
+ *result = ::BOOST_MOVE_NAMESPACE::move(*l);
 }
 return result;
}
@@ -777,7 +793,7 @@
//! \code
//! for (; first != last; ++result, ++first)
//! new (static_cast<void*>(&*result))
-//! typename iterator_traits<ForwardIterator>::value_type(boost::interprocess::move(*first));
+//! typename iterator_traits<ForwardIterator>::value_type(BOOST_MOVE_NAMESPACE::move(*first));
//! \endcode
//!
//! Returns: result
@@ -792,7 +808,7 @@
{
 typedef typename std::iterator_traits::value_type input_value_type;
 while (f != l) {
- ::new(static_cast<void*>(&*r)) input_value_type(boost::interprocess::move(*f));
+ ::new(static_cast<void*>(&*r)) input_value_type(BOOST_MOVE_NAMESPACE::move(*f));
 ++f; ++r;
 }
 return r;
@@ -823,7 +839,7 @@
F uninitialized_move_move_iterator(I f, I l, F r,
 typename enable_if< is_movable<typename I::value_type> >::type* = 0)
{
- return ::boost::interprocess::uninitialized_move(f, l, r);
+ return ::BOOST_MOVE_NAMESPACE::uninitialized_move(f, l, r);
}

template
@@ -843,7 +859,7 @@
F uninitialized_copy_or_move(I f, I l, F r,
 typename enable_if< move_detail::is_move_iterator >::type* = 0)
{
- return ::boost::interprocess::move_detail::uninitialized_move_move_iterator(f, l, r);
+ return ::BOOST_MOVE_NAMESPACE::move_detail::uninitialized_move_move_iterator(f, l, r);
}

/// @endcond
@@ -905,8 +921,8 @@
//! means that if t1 of type T is being moved to an already moved value t2,
//! there is no need to call t1's destructor:
//! <pre>
-//! T t1, t2, t3(::boost::interprocess::move(t2));
-//! t2 = ::boost::interprocess::move(t1);
+//! T t1, t2, t3(::BOOST_MOVE_NAMESPACE::move(t2));
+//! t2 = ::BOOST_MOVE_NAMESPACE::move(t1);
//! //There is no need to call t1's destructor
//! </pre>
//! This optimization is used to improve containers' performance.
@@ -919,7 +935,37 @@
 : public has_trivial_destructor_after_move<T>
{};

-} //namespace interprocess {
+#ifdef BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
+
+#define BOOST_INTERPROCESS_ENABLE_MOVE_EMULATION(TYPE) BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION(TYPE)
+#define BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE)
+#define BOOST_INTERPROCESS_COPYABLE_AND_MOVABLE(TYPE) BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE)
+#define BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
+#define BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
+#define BOOST_INTERPROCESS_RV_REF(TYPE) BOOST_MOVE_MACRO_RV_REF(TYPE)
+#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE) BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE)
+#define BOOST_INTERPROCESS_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_MOVE_MACRO_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
+#define BOOST_INTERPROCESS_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_MOVE_MACRO_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
+#define BOOST_INTERPROCESS_FWD_REF(TYPE) BOOST_MOVE_MACRO_FWD_REF(TYPE)
+#define BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(TYPE) BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE)
+
+#else
+
+#define BOOST_ENABLE_MOVE_EMULATION(TYPE) BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION(TYPE)
+#define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE)
+#define BOOST_COPYABLE_AND_MOVABLE(TYPE) BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE)
+#define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
+#define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
+#define BOOST_RV_REF(TYPE) BOOST_MOVE_MACRO_RV_REF(TYPE)
+#define BOOST_COPY_ASSIGN_REF(TYPE) BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE)
+#define BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_MOVE_MACRO_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
+#define BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_MOVE_MACRO_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
+#define BOOST_FWD_REF(TYPE) BOOST_MOVE_MACRO_FWD_REF(TYPE)
+#define BOOST_CATCH_CONST_RLVALUE(TYPE) BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE)
+
+#endif
+
+INTERPROCESS_NAMESPACE_END
} //namespace boost {

#endif //#ifndef BOOST_MOVE_HPP

Modified: trunk/boost/interprocess/detail/os_file_functions.hpp
==============================================================================
--- trunk/boost/interprocess/detail/os_file_functions.hpp (original)
+++ trunk/boost/interprocess/detail/os_file_functions.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -13,6 +13,7 @@

#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/errors.hpp>
#include <string>

#if (defined BOOST_INTERPROCESS_WINDOWS)
@@ -262,8 +263,7 @@
 //if(::SetFileAttributes(strFilePath.c_str(), winapi::file_attribute_normal) == 0)
 //return winapi::get_last_error();
 // Delete file
- if(winapi::delete_file(strFilePath.c_str()) == 0)
- return false;
+ winapi::delete_file(strFilePath.c_str());
 }
 }
 //Go to the next file
@@ -551,6 +551,19 @@

#endif //#if (defined BOOST_INTERPROCESS_WINDOWS)

+inline bool open_or_create_directory(const char *dir_name)
+{
+ //If fails, check that it's because it already exists
+ if(!create_directory(dir_name)){
+ error_info info(system_error_code());
+ if(info.get_error_code() != already_exists_error){
+ return false;
+ }
+ }
+ return true;
+}
+
+
} //namespace detail{
} //namespace interprocess {
} //namespace boost {

Modified: trunk/boost/interprocess/detail/tmp_dir_helpers.hpp
==============================================================================
--- trunk/boost/interprocess/detail/tmp_dir_helpers.hpp (original)
+++ trunk/boost/interprocess/detail/tmp_dir_helpers.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -102,26 +102,30 @@
    tmp_name += "/boost_interprocess";
}

-
-inline void tmp_filename(const char *filename, std::string &tmp_name)
+inline void tmp_folder(std::string &tmp_name)
{
    get_tmp_base_dir(tmp_name);
- //Remove final null.
- tmp_name += "/";
    #ifdef BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
+ tmp_name += "/";
    get_bootstamp(tmp_name, true);
- tmp_name += '/';
    #endif
+}
+
+inline void tmp_filename(const char *filename, std::string &tmp_name)
+{
+ tmp_folder(tmp_name);
+ tmp_name += "/";
    tmp_name += filename;
}

-inline void create_tmp_dir_and_get_filename(const char *filename, std::string &tmp_name)
+inline void create_tmp_dir(std::string &tmp_name)
{
    //First get the temp directory
- get_tmp_base_dir(tmp_name);
+ std::string root_tmp_name;
+ get_tmp_base_dir(root_tmp_name);

    //If fails, check that it's because already exists
- if(!create_directory(tmp_name.c_str())){
+ if(!create_directory(root_tmp_name.c_str())){
       error_info info(system_error_code());
       if(info.get_error_code() != already_exists_error){
          throw interprocess_exception(info);
@@ -129,13 +133,7 @@
    }

    #ifdef BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
- //Create a new subdirectory with the bootstamp
- std::string root_tmp_name = tmp_name;
- tmp_name += '/';
- //Obtain bootstamp string
- std::string bootstamp;
- get_bootstamp(bootstamp);
- tmp_name += bootstamp;
+ tmp_folder(tmp_name);

    //If fails, check that it's because already exists
    if(!create_directory(tmp_name.c_str())){
@@ -145,12 +143,16 @@
       }
    }
    //Now erase all old directories created in the previous boot sessions
- delete_subdirectories(root_tmp_name, bootstamp.c_str());
+ std::string subdir = tmp_name;
+ subdir.erase(0, root_tmp_name.size()+1);
+ delete_subdirectories(root_tmp_name, subdir.c_str());
    #endif
+}

- //Add filename
- tmp_name += '/';
- tmp_name += filename;
+inline void create_tmp_dir_and_get_filename(const char *filename, std::string &tmp_name)
+{
+ create_tmp_dir(tmp_name);
+ tmp_filename(filename, tmp_name);
}

inline void add_leading_slash(const char *name, std::string &new_name)

Modified: trunk/boost/interprocess/detail/win32_api.hpp
==============================================================================
--- trunk/boost/interprocess/detail/win32_api.hpp (original)
+++ trunk/boost/interprocess/detail/win32_api.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -349,6 +349,20 @@
    unsigned char Reserved1[SystemTimeOfDayInfoLength];
};

+struct interprocess_by_handle_file_information
+{
+ unsigned long dwFileAttributes;
+ interprocess_filetime ftCreationTime;
+ interprocess_filetime ftLastAccessTime;
+ interprocess_filetime ftLastWriteTime;
+ unsigned long dwVolumeSerialNumber;
+ unsigned long nFileSizeHigh;
+ unsigned long nFileSizeLow;
+ unsigned long nNumberOfLinks;
+ unsigned long nFileIndexHigh;
+ unsigned long nFileIndexLow;
+};
+
enum system_information_class {
    system_basic_information = 0,
    system_performance_information = 2,
@@ -433,6 +447,8 @@
extern "C" __declspec(dllimport) int __stdcall FreeLibrary(void *);
extern "C" __declspec(dllimport) void *__stdcall GetProcAddress(void *, const char*);
extern "C" __declspec(dllimport) void *__stdcall GetModuleHandleA(const char*);
+extern "C" __declspec(dllimport) void *__stdcall GetFileInformationByHandle(void *, interprocess_by_handle_file_information*);
+

//API function typedefs
//Pointer to functions
@@ -626,6 +642,9 @@
inline bool write_file(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped)
{ return 0 != WriteFile(hnd, buffer, bytes_to_write, bytes_written, overlapped); }

+inline bool get_file_information_by_handle(void *hnd, interprocess_by_handle_file_information *info)
+{ return 0 != GetFileInformationByHandle(hnd, info); }
+
inline long interlocked_increment(long volatile *addr)
{ return BOOST_INTERLOCKED_INCREMENT(addr); }

Modified: trunk/boost/interprocess/managed_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/managed_shared_memory.hpp (original)
+++ trunk/boost/interprocess/managed_shared_memory.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -19,6 +19,7 @@
#include <boost/interprocess/detail/workaround.hpp>

#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/exceptions.hpp>
#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/creation_tags.hpp>

Modified: trunk/boost/interprocess/offset_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/offset_ptr.hpp (original)
+++ trunk/boost/interprocess/offset_ptr.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -151,7 +151,7 @@
 pointer get()const
 { return static_cast<pointer>(this->get_pointer()); }

- std::ptrdiff_t get_offset()
+ std::ptrdiff_t get_offset() const
 { return m_offset; }

 //!Pointer-like -> operator. It can return 0 pointer.

Modified: trunk/boost/interprocess/segment_manager.hpp
==============================================================================
--- trunk/boost/interprocess/segment_manager.hpp (original)
+++ trunk/boost/interprocess/segment_manager.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -499,6 +499,24 @@
 void atomic_func(Func &f)
 { scoped_lock<rmutex> guard(m_header); f(); }

+ //!Tries to calls a functor guaranteeing that no new construction, search or
+ //!destruction will be executed by any process while executing the object
+ //!function call. If the atomic function can't be immediatelly executed
+ //!because the internal mutex is already locked, returns false.
+ //!If the functor throws, this function throws.
+ template <class Func>
+ bool try_atomic_func(Func &f)
+ {
+ scoped_lock<rmutex> guard(m_header, try_to_lock);
+ if(guard){
+ f();
+ return true;
+ }
+ else{
+ return false;
+ }
+ }
+
 //!Destroys a previously created unique instance.
 //!Returns false if the object was not present.
 template <class T>

Modified: trunk/boost/interprocess/shared_memory_object.hpp
==============================================================================
--- trunk/boost/interprocess/shared_memory_object.hpp (original)
+++ trunk/boost/interprocess/shared_memory_object.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -214,7 +214,7 @@
       //Make sure a temporary path is created for shared memory
       std::string shmfile;
       detail::tmp_filename(filename, shmfile);
- return detail::delete_file(shmfile.c_str()) == 0;
+ return detail::delete_file(shmfile.c_str());
    }
    catch(...){
       return false;

Modified: trunk/boost/interprocess/smart_ptr/shared_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/smart_ptr/shared_ptr.hpp (original)
+++ trunk/boost/interprocess/smart_ptr/shared_ptr.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -108,7 +108,7 @@
 typedef typename boost::pointer_to_other
 <typename VoidAllocator::pointer, const VoidAllocator>::type const_allocator_pointer;

- BOOST_COPYABLE_AND_MOVABLE(shared_ptr)
+ BOOST_INTERPROCESS_COPYABLE_AND_MOVABLE(shared_ptr)
 public:

 //!Constructs an empty shared_ptr.

Modified: trunk/boost/interprocess/windows_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/windows_shared_memory.hpp (original)
+++ trunk/boost/interprocess/windows_shared_memory.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -80,6 +80,7 @@
    //!After the call, "moved" does not represent any shared memory object.
    //!Does not throw
    windows_shared_memory(BOOST_INTERPROCESS_RV_REF(windows_shared_memory) moved)
+ : m_handle(0)
    { this->swap(moved); }

    //!Moves the ownership of "moved"'s shared memory to *this.

Modified: trunk/boost/intrusive/avl_set.hpp
==============================================================================
--- trunk/boost/intrusive/avl_set.hpp (original)
+++ trunk/boost/intrusive/avl_set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -74,6 +74,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;
@@ -1264,6 +1266,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;

Modified: trunk/boost/intrusive/avltree.hpp
==============================================================================
--- trunk/boost/intrusive/avltree.hpp (original)
+++ trunk/boost/intrusive/avltree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -113,7 +113,7 @@
 <pointer, node>::type node_ptr;
 typedef typename boost::pointer_to_other
 <node_ptr, const node>::type const_node_ptr;
- typedef avltree_algorithms<node_traits> node_algorithms;
+ typedef avltree_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
 static const bool stateful_value_traits = detail::store_cont_ptr_on_it<avltree_impl>::value;
@@ -167,7 +167,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
 }

 size_traits &priv_size_traits()
@@ -1398,7 +1398,7 @@
 static avltree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: trunk/boost/intrusive/avltree_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/avltree_algorithms.hpp (original)
+++ trunk/boost/intrusive/avltree_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -104,7 +104,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
 }
 /// @endcond

Modified: trunk/boost/intrusive/derivation_value_traits.hpp
==============================================================================
--- trunk/boost/intrusive/derivation_value_traits.hpp (original)
+++ trunk/boost/intrusive/derivation_value_traits.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -44,10 +44,10 @@
 { return node_ptr(&value); }

 static pointer to_value_ptr(node_ptr n)
- { return pointer(static_cast<T*>(detail::get_pointer(n))); }
+ { return pointer(static_cast<T*>(detail::boost_intrusive_get_pointer(n))); }

 static const_pointer to_value_ptr(const_node_ptr n)
- { return const_pointer(static_cast<const T*>(detail::get_pointer(n))); }
+ { return const_pointer(static_cast<const T*>(detail::boost_intrusive_get_pointer(n))); }
};

} //namespace intrusive

Modified: trunk/boost/intrusive/detail/hashtable_node.hpp
==============================================================================
--- trunk/boost/intrusive/detail/hashtable_node.hpp (original)
+++ trunk/boost/intrusive/detail/hashtable_node.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -36,6 +36,7 @@

template<int Dummy>
const std::size_t prime_list_holder<Dummy>::prime_list[] = {
+ 3ul, 7ul, 11ul, 17ul, 29ul,
 53ul, 97ul, 193ul, 389ul, 769ul,
 1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
 49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
@@ -164,10 +165,10 @@
 { return *this->operator ->(); }

 pointer operator->() const
- { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node()))); }
+ { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node()))); }

 const Container *get_container() const
- { return detail::get_pointer(cont_); }
+ { return detail::boost_intrusive_get_pointer(cont_); }

 const real_value_traits *get_real_value_traits() const
 { return &this->get_container()->get_real_value_traits(); }
@@ -175,8 +176,8 @@
 private:
 void increment()
 {
- const Container *cont = detail::get_pointer(cont_);
- bucket_type* buckets = detail::get_pointer(cont->bucket_pointer());
+ const Container *cont = detail::boost_intrusive_get_pointer(cont_);
+ bucket_type* buckets = detail::boost_intrusive_get_pointer(cont->bucket_pointer());
 size_type buckets_len = cont->bucket_count();

 ++slist_it_;

Modified: trunk/boost/intrusive/detail/list_node.hpp
==============================================================================
--- trunk/boost/intrusive/detail/list_node.hpp (original)
+++ trunk/boost/intrusive/detail/list_node.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -64,11 +64,9 @@
 : public std::iterator
 < std::bidirectional_iterator_tag
 , typename Container::value_type
- , typename std::iterator_traits<typename Container::value_type*>::difference_type
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &
+ , typename Container::difference_type
+ , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
+ , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
>
{
 protected:
@@ -83,10 +81,8 @@

 public:
 typedef typename Container::value_type value_type;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *pointer;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &reference;
+ typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
+ typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;

 list_iterator()
 : members_ (node_ptr(0), 0)
@@ -133,17 +129,17 @@
 return result;
 }

- bool operator== (const list_iterator& i) const
- { return members_.nodeptr_ == i.pointed_node(); }
+ friend bool operator== (const list_iterator& l, const list_iterator& r)
+ { return l.pointed_node() == r.pointed_node(); }

- bool operator!= (const list_iterator& i) const
- { return !operator== (i); }
+ friend bool operator!= (const list_iterator& l, const list_iterator& r)
+ { return !(l == r); }

 reference operator*() const
 { return *operator->(); }

 pointer operator->() const
- { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }

 const Container *get_container() const
 {

Modified: trunk/boost/intrusive/detail/slist_node.hpp
==============================================================================
--- trunk/boost/intrusive/detail/slist_node.hpp (original)
+++ trunk/boost/intrusive/detail/slist_node.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -56,11 +56,9 @@
 : public std::iterator
 < std::forward_iterator_tag
 , typename Container::value_type
- , typename std::iterator_traits<typename Container::value_type*>::difference_type
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &
+ , typename Container::difference_type
+ , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
+ , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
>
{
 protected:
@@ -75,10 +73,8 @@

 public:
 typedef typename Container::value_type value_type;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *pointer;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &reference;
+ typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
+ typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;

 slist_iterator()
 : members_ (node_ptr(0), 0)
@@ -112,17 +108,17 @@
 return result;
 }

- bool operator== (const slist_iterator& i) const
- { return members_.nodeptr_ == i.pointed_node(); }
+ friend bool operator== (const slist_iterator& l, const slist_iterator& r)
+ { return l.pointed_node() == r.pointed_node(); }

- bool operator!= (const slist_iterator& i) const
- { return !operator== (i); }
+ friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
+ { return !(l == r); }

 reference operator*() const
 { return *operator->(); }

 pointer operator->() const
- { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }

 const Container *get_container() const
 {

Modified: trunk/boost/intrusive/detail/tree_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/detail/tree_algorithms.hpp (original)
+++ trunk/boost/intrusive/detail/tree_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -18,6 +18,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef>
#include <boost/intrusive/detail/utilities.hpp>
+//iG pending #include <boost/pointer_cast.hpp>

namespace boost {
namespace intrusive {
@@ -140,7 +141,8 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
+ //iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
 }
 /// @endcond

Modified: trunk/boost/intrusive/detail/tree_node.hpp
==============================================================================
--- trunk/boost/intrusive/detail/tree_node.hpp (original)
+++ trunk/boost/intrusive/detail/tree_node.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -73,11 +73,9 @@
 : public std::iterator
 < std::bidirectional_iterator_tag
 , typename Container::value_type
- , typename std::iterator_traits<typename Container::value_type*>::difference_type
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *
- , typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &
+ , typename Container::difference_type
+ , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
+ , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
>
{
 protected:
@@ -93,10 +91,9 @@

 public:
 typedef typename Container::value_type value_type;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type *pointer;
- typedef typename detail::add_const_if_c
- <typename Container::value_type, IsConst>::type &reference;
+ typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
+ typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;
+

 tree_iterator()
 : members_ (0, 0)
@@ -143,17 +140,17 @@
 return result;
 }

- bool operator== (const tree_iterator& i) const
- { return members_.nodeptr_ == i.pointed_node(); }
+ friend bool operator== (const tree_iterator& l, const tree_iterator& r)
+ { return l.pointed_node() == r.pointed_node(); }

- bool operator!= (const tree_iterator& i) const
- { return !operator== (i); }
+ friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
+ { return !(l == r); }

 reference operator*() const
 { return *operator->(); }

 pointer operator->() const
- { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }

 const Container *get_container() const
 { return static_cast<const Container*>(members_.get_ptr()); }

Modified: trunk/boost/intrusive/detail/utilities.hpp
==============================================================================
--- trunk/boost/intrusive/detail/utilities.hpp (original)
+++ trunk/boost/intrusive/detail/utilities.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -122,10 +122,10 @@
 { return ptr;}
};

-//!Overload for smart pointers to avoid ADL problems with get_pointer
+//!Overload for smart pointers to avoid ADL problems with boost_intrusive_get_pointer
template<class Ptr>
inline typename smart_ptr_type<Ptr>::pointer
-get_pointer(const Ptr &ptr)
+boost_intrusive_get_pointer(const Ptr &ptr)
{ return smart_ptr_type<Ptr>::get(ptr); }

//This functor compares a stored value
@@ -319,7 +319,7 @@
 {}

 const void *get_ptr() const
- { return detail::get_pointer(const_void_ptr_); }
+ { return detail::boost_intrusive_get_pointer(const_void_ptr_); }

 ConstVoidPtr const_void_ptr_;
};
@@ -422,13 +422,13 @@
 static pointer to_value_ptr(node_ptr n)
 {
 return detail::parent_from_member<T, Hook>
- (static_cast<Hook*>(detail::get_pointer(n)), P);
+ (static_cast<Hook*>(detail::boost_intrusive_get_pointer(n)), P);
 }

 static const_pointer to_value_ptr(const_node_ptr n)
 {
 return detail::parent_from_member<T, Hook>
- (static_cast<const Hook*>(detail::get_pointer(n)), P);
+ (static_cast<const Hook*>(detail::boost_intrusive_get_pointer(n)), P);
 }
};

@@ -632,6 +632,64 @@
 { return *(this->get_real_value_traits()->to_value_ptr(npointer(&arg))); }
};

+//This is not standard, but should work with all compilers
+union max_align
+{
+ char char_;
+ short short_;
+ int int_;
+ long long_;
+ #ifdef BOOST_HAS_LONG_LONG
+ long long long_long_;
+ #endif
+ float float_;
+ double double_;
+ long double long_double_;
+ void * void_ptr_;
+};
+
+template<class T, std::size_t N>
+class array_initializer
+{
+ public:
+ template<class CommonInitializer>
+ array_initializer(const CommonInitializer &init)
+ {
+ char *init_buf = (char*)rawbuf;
+ std::size_t i = 0;
+ try{
+ for(; i != N; ++i){
+ new(init_buf)T(init);
+ init_buf += sizeof(T);
+ }
+ }
+ catch(...){
+ while(i--){
+ init_buf -= sizeof(T);
+ ((T*)init_buf)->~T();
+ }
+ throw;
+ }
+ }
+
+ operator T* ()
+ { return (T*)(rawbuf); }
+
+ operator const T*() const
+ { return (const T*)(rawbuf); }
+
+ ~array_initializer()
+ {
+ char *init_buf = (char*)rawbuf + N*sizeof(T);
+ for(std::size_t i = 0; i != N; ++i){
+ init_buf -= sizeof(T);
+ ((T*)init_buf)->~T();
+ }
+ }
+
+ private:
+ detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1];
+};

} //namespace detail
} //namespace intrusive

Modified: trunk/boost/intrusive/hashtable.hpp
==============================================================================
--- trunk/boost/intrusive/hashtable.hpp (original)
+++ trunk/boost/intrusive/hashtable.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -886,7 +886,7 @@
 }
 else{
 size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = detail::get_pointer(this->priv_buckets());
+ const bucket_type *b = detail::boost_intrusive_get_pointer(this->priv_buckets());
 for (size_type n = 0; n < buckets_len; ++n, ++b){
 if(!b->empty()){
 return false;
@@ -909,7 +909,7 @@
 else{
 size_type len = 0;
 size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = detail::get_pointer(this->priv_buckets());
+ const bucket_type *b = detail::boost_intrusive_get_pointer(this->priv_buckets());
 for (size_type n = 0; n < buckets_len; ++n, ++b){
 len += b->size();
 }
@@ -1229,8 +1229,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
- iterator erase(const_iterator i)
- { return this->erase_and_dispose(i, detail::null_disposer()); }
+ void erase(const_iterator i)
+ { this->erase_and_dispose(i, detail::null_disposer()); }

 //! Effects: Erases the range pointed to by b end e.
 //!
@@ -1241,8 +1241,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
- iterator erase(const_iterator b, const_iterator e)
- { return this->erase_and_dispose(b, e, detail::null_disposer()); }
+ void erase(const_iterator b, const_iterator e)
+ { this->erase_and_dispose(b, e, detail::null_disposer()); }

 //! Effects: Erases all the elements with the given value.
 //!
@@ -1295,18 +1295,15 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator i, Disposer disposer
+ void erase_and_dispose(const_iterator i, Disposer disposer
 /// @cond
 , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0
 /// @endcond
 )
 {
- iterator ret(i.unconst());
- ++ret;
 priv_erase(i, disposer, optimize_multikey_t());
 this->priv_size_traits().decrement();
 priv_erasure_update_cache();
- return ret;
 }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
@@ -1322,7 +1319,7 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
+ void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
 {
 if(b != e){
 //Get the bucket number and local iterator for both iterators
@@ -1347,7 +1344,6 @@
 priv_erase_range(before_first_local_it, first_bucket_num, last_local_it, last_bucket_num, disposer);
 priv_erasure_update_cache(first_bucket_num, last_bucket_num);
 }
- return e.unconst();
 }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
@@ -2139,8 +2135,8 @@
 }

 //! Effects: Returns the nearest new bucket count optimized for
- //! the container that is bigger than n. This suggestion can be used
- //! to create bucket arrays with a size that will usually improve
+ //! the container that is bigger or equal than n. This suggestion can be
+ //! used to create bucket arrays with a size that will usually improve
 //! container's performance. If such value does not exist, the
 //! higher possible value is returned.
 //!
@@ -2153,15 +2149,15 @@
 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);
 if(bound == primes_end)
- bound--;
+ --bound;
 return size_type(*bound);
 }

 //! Effects: Returns the nearest new bucket count optimized for
- //! the container that is smaller than n. This suggestion can be used
- //! to create bucket arrays with a size that will usually improve
+ //! the container that is smaller or equal than n. This suggestion can be
+ //! used to create bucket arrays with a size that will usually improve
 //! container's performance. If such value does not exist, the
- //! lower possible value is returned.
+ //! lowest possible value is returned.
 //!
 //! Complexity: Amortized constant time.
 //!
@@ -2171,8 +2167,8 @@
 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::upper_bound(primes, primes_end, n);
- if(bound != primes_end)
- bound--;
+ if(bound != primes)
+ --bound;
 return size_type(*bound);
 }

@@ -2240,7 +2236,7 @@
 { return this->priv_real_bucket_traits().bucket_count(); }

 static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::get_pointer(ptr))); }
+ { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }

 node &priv_value_to_node(value_type &v)
 { return *this->get_real_value_traits().to_node_ptr(v); }

Modified: trunk/boost/intrusive/list.hpp
==============================================================================
--- trunk/boost/intrusive/list.hpp (original)
+++ trunk/boost/intrusive/list.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -30,6 +30,7 @@
#include <algorithm>
#include <functional>
#include <cstddef>
+//iG pending #include <boost/pointer_cast.hpp>

namespace boost {
namespace intrusive {
@@ -129,8 +130,8 @@
 //Const cast emulation for smart pointers
 static node_ptr uncast(const_node_ptr ptr)
 {
- //return node_ptr(detail::get_pointer(ptr)));
- return const_cast<node*>(detail::get_pointer(ptr));
+ return const_cast<node*>(detail::boost_intrusive_get_pointer(ptr));
+ //iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
 }

 node_ptr get_root_node()
@@ -172,6 +173,22 @@
 real_value_traits &get_real_value_traits(detail::bool_<true>)
 { return data_.get_value_traits(*this); }

+ const value_traits &get_value_traits() const
+ { return data_; }
+
+ value_traits &get_value_traits()
+ { return data_; }
+
+ protected:
+ node &prot_root_node()
+ { return data_.root_plus_size_.root_; }
+
+ node const &prot_root_node() const
+ { return data_.root_plus_size_.root_; }
+
+ void prot_set_size(size_type s)
+ { data_.root_plus_size_.set_size(s); }
+
 /// @endcond

 public:
@@ -971,8 +988,8 @@
 {
 if(node_traits::get_next(this->get_root_node())
 != node_traits::get_previous(this->get_root_node())){
- list_impl carry;
- list_impl counter[64];
+ list_impl carry(this->get_value_traits());
+ detail::array_initializer<list_impl, 64> counter(this->get_value_traits());
 int fill = 0;
 while(!this->empty()){
 carry.splice(carry.cbegin(), *this, this->cbegin());
@@ -1268,7 +1285,7 @@
 static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 root_plus_size *r = detail::parent_from_member<root_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &root_plus_size::root_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &root_plus_size::root_);
 data_t *d = detail::parent_from_member<data_t, root_plus_size>
 ( r, &data_t::root_plus_size_);
 list_impl *s = detail::parent_from_member<list_impl, data_t>(d, &list_impl::data_);

Modified: trunk/boost/intrusive/member_value_traits.hpp
==============================================================================
--- trunk/boost/intrusive/member_value_traits.hpp (original)
+++ trunk/boost/intrusive/member_value_traits.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -49,13 +49,13 @@
 static pointer to_value_ptr(node_ptr n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (detail::get_pointer(n), PtrToMember));
+ (detail::boost_intrusive_get_pointer(n), PtrToMember));
 }

 static const_pointer to_value_ptr(const_node_ptr n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (detail::get_pointer(n), PtrToMember));
+ (detail::boost_intrusive_get_pointer(n), PtrToMember));
 }
};

Modified: trunk/boost/intrusive/rbtree.hpp
==============================================================================
--- trunk/boost/intrusive/rbtree.hpp (original)
+++ trunk/boost/intrusive/rbtree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -33,6 +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>

namespace boost {
namespace intrusive {
@@ -110,10 +111,8 @@
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename node_traits::node_ptr node_ptr;
+ typedef typename node_traits::const_node_ptr const_node_ptr;
 typedef rbtree_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
@@ -152,7 +151,7 @@
 {}
 node_plus_pred_t node_plus_pred_;
 } data_;
-
+
 const value_compare &priv_comp() const
 { return data_.node_plus_pred_.get(); }

@@ -167,7 +166,8 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
+//iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
 }

 size_traits &priv_size_traits()
@@ -188,6 +188,19 @@
 real_value_traits &get_real_value_traits(detail::bool_<true>)
 { return data_.get_value_traits(*this); }

+ protected:
+ value_compare &prot_comp()
+ { return priv_comp(); }
+
+ const node &prot_header_node() const
+ { return priv_header(); }
+
+ node &prot_header_node()
+ { return priv_header(); }
+
+ void prot_set_size(size_type s)
+ { this->priv_size_traits().set_size(s); }
+
 /// @endcond

 public:
@@ -1390,7 +1403,7 @@
 static rbtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: trunk/boost/intrusive/rbtree_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/rbtree_algorithms.hpp (original)
+++ trunk/boost/intrusive/rbtree_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -157,7 +157,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
 }
 /// @endcond

Modified: trunk/boost/intrusive/set.hpp
==============================================================================
--- trunk/boost/intrusive/set.hpp (original)
+++ trunk/boost/intrusive/set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -75,9 +75,19 @@
 typedef typename implementation_defined::const_node_ptr const_node_ptr;
 typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+ //static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
+
 /// @cond
 private:
 tree_type tree_;
+
+ protected:
+ node &prot_header_node(){ return tree_.prot_header_node(); }
+ node const &prot_header_node() const{ return tree_.prot_header_node(); }
+ void prot_set_size(size_type s){ tree_.prot_set_size(s); }
+ value_compare &prot_comp(){ return tree_.prot_comp(); }
+
 /// @endcond

 public:
@@ -1265,9 +1275,18 @@
 typedef typename implementation_defined::const_node_ptr const_node_ptr;
 typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+ //static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
+
 /// @cond
 private:
 tree_type tree_;
+
+ protected:
+ node &prot_header_node(){ return tree_.prot_header_node(); }
+ node const &prot_header_node() const{ return tree_.prot_header_node(); }
+ void prot_set_size(size_type s){ tree_.prot_set_size(s); }
+ value_compare &prot_comp(){ return tree_.prot_comp(); }
 /// @endcond

 public:
@@ -1450,7 +1469,7 @@
 //!
 //! Throws: Nothing.
 //!
- //! Complexity: Constant.
+ //! Complexity: Logarithmic.
 static multiset_impl &container_from_iterator(iterator it)
 {
 return *detail::parent_from_member<multiset_impl, tree_type>
@@ -1464,7 +1483,7 @@
 //!
 //! Throws: Nothing.
 //!
- //! Complexity: Constant.
+ //! Complexity: Logarithmic.
 static const multiset_impl &container_from_iterator(const_iterator it)
 {
 return *detail::parent_from_member<multiset_impl, tree_type>

Modified: trunk/boost/intrusive/sgtree.hpp
==============================================================================
--- trunk/boost/intrusive/sgtree.hpp (original)
+++ trunk/boost/intrusive/sgtree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -310,7 +310,7 @@
 { return data_.node_plus_pred_.header_plus_alpha_.header_; }

 static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::get_pointer(ptr))); }
+ { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.size_traits_; }
@@ -1631,7 +1631,7 @@
 static sgtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_alpha *r = detail::parent_from_member<header_plus_alpha, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_alpha>(r, &node_plus_pred_t::header_plus_alpha_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: trunk/boost/intrusive/sgtree_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/sgtree_algorithms.hpp (original)
+++ trunk/boost/intrusive/sgtree_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -70,7 +70,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
 }
 /// @endcond

Modified: trunk/boost/intrusive/slist.hpp
==============================================================================
--- trunk/boost/intrusive/slist.hpp (original)
+++ trunk/boost/intrusive/slist.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -31,6 +31,7 @@
#include <algorithm>
#include <cstddef> //std::size_t
#include <utility> //std::pair
+//iG pending #include <boost/pointer_cast.hpp>

namespace boost {
namespace intrusive {
@@ -129,10 +130,9 @@
 typedef slist_iterator<slist_impl, true> const_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <pointer, const node>::type const_node_ptr;
+ typedef typename node_traits::node_ptr node_ptr;
+ typedef typename node_traits::const_node_ptr const_node_ptr;
+
 typedef typename detail::if_c
 < Config::linear
 , linear_slist_algorithms<node_traits>
@@ -206,7 +206,8 @@
 { data_.root_plus_size_.last_ = n; }

 static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::get_pointer(ptr))); }
+ { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }
+//iG pending { return boost::const_pointer_cast<node>(ptr); }

 void set_default_constructed_state()
 {
@@ -251,6 +252,22 @@
 real_value_traits &get_real_value_traits(detail::bool_<true>)
 { return data_.get_value_traits(*this); }

+ const value_traits &get_value_traits() const
+ { return data_; }
+
+ value_traits &get_value_traits()
+ { return data_; }
+
+ protected:
+ node &prot_root_node()
+ { return data_.root_plus_size_.root_; }
+
+ node const &prot_root_node() const
+ { return data_.root_plus_size_.root_; }
+
+ void prot_set_size(size_type s)
+ { data_.root_plus_size_.set_size(s); }
+
 /// @endcond

 public:
@@ -1220,7 +1237,7 @@
 //! assigned to the last spliced element or prev if x is empty.
 //! This iterator can be used as new "prev" iterator for a new splice_after call.
 //! that will splice new values after the previously spliced values.
- void splice(const_iterator it, slist_impl &x, iterator *last = 0)
+ void splice(const_iterator it, slist_impl &x, const_iterator *last = 0)
 { this->splice_after(this->previous(it), x, last); }

 //! Requires: it p must be a valid iterator of *this.
@@ -1295,8 +1312,9 @@
 {
 if (node_traits::get_next(node_traits::get_next(this->get_root_node()))
 != this->get_root_node()) {
- slist_impl carry;
- slist_impl counter[64];
+
+ slist_impl carry(this->get_value_traits());
+ detail::array_initializer<slist_impl, 64> counter(this->get_value_traits());
 int fill = 0;
 const_iterator last_inserted;
 while(!this->empty()){
@@ -1879,7 +1897,7 @@
 //singly linked lists (because "end" is represented by the null pointer)
 BOOST_STATIC_ASSERT(!linear);
 root_plus_size *r = detail::parent_from_member<root_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
 data_t *d = detail::parent_from_member<data_t, root_plus_size>
 ( r, &data_t::root_plus_size_);
 slist_impl *s = detail::parent_from_member<slist_impl, data_t>(d, &slist_impl::data_);

Modified: trunk/boost/intrusive/splay_set.hpp
==============================================================================
--- trunk/boost/intrusive/splay_set.hpp (original)
+++ trunk/boost/intrusive/splay_set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -74,6 +74,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;
@@ -1286,6 +1288,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;

Modified: trunk/boost/intrusive/splaytree.hpp
==============================================================================
--- trunk/boost/intrusive/splaytree.hpp (original)
+++ trunk/boost/intrusive/splaytree.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -166,7 +166,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
 }

 size_traits &priv_size_traits()
@@ -1405,7 +1405,7 @@
 static splaytree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: trunk/boost/intrusive/splaytree_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/splaytree_algorithms.hpp (original)
+++ trunk/boost/intrusive/splaytree_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -147,7 +147,7 @@
 private:
 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
 }
 /// @endcond

Modified: trunk/boost/intrusive/treap.hpp
==============================================================================
--- trunk/boost/intrusive/treap.hpp (original)
+++ trunk/boost/intrusive/treap.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -116,7 +116,7 @@
 <pointer, node>::type node_ptr;
 typedef typename boost::pointer_to_other
 <node_ptr, const node>::type const_node_ptr;
- typedef treap_algorithms<node_traits> node_algorithms;
+ typedef treap_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
 static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
@@ -184,7 +184,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
 }

 size_traits &priv_size_traits()
@@ -1482,7 +1482,7 @@
 static treap_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 typename node_plus_pred_t::header_plus_priority_size *n =
 detail::parent_from_member
 < typename node_plus_pred_t::header_plus_priority_size

Modified: trunk/boost/intrusive/treap_algorithms.hpp
==============================================================================
--- trunk/boost/intrusive/treap_algorithms.hpp (original)
+++ trunk/boost/intrusive/treap_algorithms.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -145,7 +145,7 @@

 static node_ptr uncast(const_node_ptr ptr)
 {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+ return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
 }
 /// @endcond

Modified: trunk/boost/intrusive/treap_set.hpp
==============================================================================
--- trunk/boost/intrusive/treap_set.hpp (original)
+++ trunk/boost/intrusive/treap_set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -75,6 +75,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;
@@ -1382,6 +1384,8 @@
    typedef typename implementation_defined::const_node_ptr const_node_ptr;
    typedef typename implementation_defined::node_algorithms node_algorithms;

+ static const bool constant_time_size = Config::constant_time_size;
+
    /// @cond
    private:
    tree_type tree_;

Modified: trunk/boost/intrusive/unordered_set.hpp
==============================================================================
--- trunk/boost/intrusive/unordered_set.hpp (original)
+++ trunk/boost/intrusive/unordered_set.hpp 2010-03-12 08:18:29 EST (Fri, 12 Mar 2010)
@@ -248,7 +248,7 @@
 //! Effects: Returns the number of elements stored in the unordered_set.
 //!
 //! Complexity: Linear to elements contained in *this if
- //! constant-time size option is enabled. Constant-time otherwise.
+ //! constant-time size option is disabled. Constant-time otherwise.
 //!
 //! Throws: Nothing.
 size_type size() const
@@ -395,8 +395,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
- iterator erase(const_iterator i)
- { return table_.erase(i); }
+ void erase(const_iterator i)
+ { table_.erase(i); }

 //! Effects: Erases the range pointed to by b end e.
 //!
@@ -407,8 +407,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
- iterator erase(const_iterator b, const_iterator e)
- { return table_.erase(b, e); }
+ void erase(const_iterator b, const_iterator e)
+ { table_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
 //!
@@ -460,12 +460,12 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator i, Disposer disposer
+ void erase_and_dispose(const_iterator i, Disposer disposer
 /// @cond
 , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0
 /// @endcond
 )
- { return table_.erase_and_dispose(i, disposer); }
+ { table_.erase_and_dispose(i, disposer); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
@@ -480,8 +480,8 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
- { return table_.erase_and_dispose(b, e, disposer); }
+ void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
+ { table_.erase_and_dispose(b, e, disposer); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
@@ -1305,7 +1305,7 @@
 //! Effects: Returns the number of elements stored in the unordered_multiset.
 //!
 //! Complexity: Linear to elements contained in *this if
- //! constant-time size option is enabled. Constant-time otherwise.
+ //! constant-time size option is disabled. Constant-time otherwise.
 //!
 //! Throws: Nothing.
 size_type size() const
@@ -1387,8 +1387,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
- iterator erase(const_iterator i)
- { return table_.erase(i); }
+ void erase(const_iterator i)
+ { table_.erase(i); }

 //! Effects: Erases the range pointed to by b end e.
 //!
@@ -1399,8 +1399,8 @@
 //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
- iterator erase(const_iterator b, const_iterator e)
- { return table_.erase(b, e); }
+ void erase(const_iterator b, const_iterator e)
+ { table_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
 //!
@@ -1453,17 +1453,17 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator i, Disposer disposer
+ void erase_and_dispose(const_iterator i, Disposer disposer
 /// @cond
 , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0
 /// @endcond
 )
- { return table_.erase_and_dispose(i, disposer); }
+ { table_.erase_and_dispose(i, disposer); }

 #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 template<class Disposer>
- iterator erase_and_dispose(const_iterator i, Disposer disposer)
- { return this->erase_and_dispose(const_iterator(i), disposer); }
+ void erase_and_dispose(const_iterator i, Disposer disposer)
+ { this->erase_and_dispose(const_iterator(i), disposer); }
 #endif

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
@@ -1479,8 +1479,8 @@
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
- iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
- { return table_.erase_and_dispose(b, e, disposer); }
+ void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
+ { table_.erase_and_dispose(b, e, disposer); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!

Next message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r60515 - in trunk/libs: interprocess/proj/vc7ide interprocess/test intrusive/test"
Previous message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r60513 - trunk/boost/interprocess/detail"

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