|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r70066 - in trunk/boost/interprocess: . allocators allocators/detail containers/container containers/container/detail containers/detail detail indexes ipc mem_algo mem_algo/detail smart_ptr sync sync/xsi
From: igaztanaga_at_[hidden]
Date: 2011-03-17 12:33:08
Author: igaztanaga
Date: 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
New Revision: 70066
URL: http://svn.boost.org/trac/boost/changeset/70066
Log:
Changes to allow interoperability between 64 and 32 processes. Pointer type is a customization of all templated code size_type's and difference_type's.
Removed:
trunk/boost/interprocess/containers/detail/
Properties modified:
trunk/boost/interprocess/ (props changed)
Text files modified:
trunk/boost/interprocess/allocators/adaptive_pool.hpp | 12
trunk/boost/interprocess/allocators/allocator.hpp | 8
trunk/boost/interprocess/allocators/cached_adaptive_pool.hpp | 16
trunk/boost/interprocess/allocators/cached_node_allocator.hpp | 19
trunk/boost/interprocess/allocators/detail/adaptive_node_pool.hpp | 7
trunk/boost/interprocess/allocators/detail/allocator_common.hpp | 53
trunk/boost/interprocess/allocators/detail/node_pool.hpp | 7
trunk/boost/interprocess/allocators/node_allocator.hpp | 12
trunk/boost/interprocess/allocators/private_adaptive_pool.hpp | 12
trunk/boost/interprocess/allocators/private_node_allocator.hpp | 12
trunk/boost/interprocess/containers/container/deque.hpp | 267 +++++----
trunk/boost/interprocess/containers/container/detail/adaptive_node_pool_impl.hpp | 171 +++--
trunk/boost/interprocess/containers/container/detail/advanced_insert_int.hpp | 28
trunk/boost/interprocess/containers/container/detail/algorithms.hpp | 4
trunk/boost/interprocess/containers/container/detail/config_begin.hpp | 13
trunk/boost/interprocess/containers/container/detail/destroyers.hpp | 2
trunk/boost/interprocess/containers/container/detail/flat_tree.hpp | 76 +-
trunk/boost/interprocess/containers/container/detail/iterators.hpp | 29
trunk/boost/interprocess/containers/container/detail/multiallocation_chain.hpp | 43
trunk/boost/interprocess/containers/container/detail/node_alloc_holder.hpp | 36
trunk/boost/interprocess/containers/container/detail/node_pool_impl.hpp | 45
trunk/boost/interprocess/containers/container/detail/pair.hpp | 68 +
trunk/boost/interprocess/containers/container/detail/preprocessor.hpp | 6
trunk/boost/interprocess/containers/container/detail/stored_ref.hpp | 4
trunk/boost/interprocess/containers/container/detail/tree.hpp | 44
trunk/boost/interprocess/containers/container/detail/utilities.hpp | 12
trunk/boost/interprocess/containers/container/detail/workaround.hpp | 4
trunk/boost/interprocess/containers/container/flat_map.hpp | 70 +-
trunk/boost/interprocess/containers/container/flat_set.hpp | 58 +-
trunk/boost/interprocess/containers/container/list.hpp | 126 ++--
trunk/boost/interprocess/containers/container/map.hpp | 86 +-
trunk/boost/interprocess/containers/container/set.hpp | 60 +-
trunk/boost/interprocess/containers/container/slist.hpp | 46
trunk/boost/interprocess/containers/container/stable_vector.hpp | 48
trunk/boost/interprocess/containers/container/string.hpp | 113 +--
trunk/boost/interprocess/containers/container/vector.hpp | 172 +++--
trunk/boost/interprocess/detail/file_wrapper.hpp | 6
trunk/boost/interprocess/detail/in_place_interface.hpp | 3
trunk/boost/interprocess/detail/intermodule_singleton.hpp | 7
trunk/boost/interprocess/detail/intersegment_ptr.hpp | 6
trunk/boost/interprocess/detail/managed_memory_impl.hpp | 60 +-
trunk/boost/interprocess/detail/managed_multi_shared_memory.hpp | 38
trunk/boost/interprocess/detail/managed_open_or_create_impl.hpp | 10
trunk/boost/interprocess/detail/move.hpp | 1147 ---------------------------------------
trunk/boost/interprocess/detail/segment_manager_helper.hpp | 111 ++-
trunk/boost/interprocess/detail/tmp_dir_helpers.hpp | 2
trunk/boost/interprocess/detail/type_traits.hpp | 44 -
trunk/boost/interprocess/detail/utilities.hpp | 12
trunk/boost/interprocess/detail/xsi_shared_memory_device.hpp | 6
trunk/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp | 6
trunk/boost/interprocess/file_mapping.hpp | 6
trunk/boost/interprocess/indexes/flat_map_index.hpp | 2
trunk/boost/interprocess/indexes/iset_index.hpp | 2
trunk/boost/interprocess/indexes/iunordered_set_index.hpp | 31
trunk/boost/interprocess/indexes/map_index.hpp | 2
trunk/boost/interprocess/indexes/unordered_map_index.hpp | 2
trunk/boost/interprocess/interprocess_fwd.hpp | 9
trunk/boost/interprocess/ipc/message_queue.hpp | 255 +++++---
trunk/boost/interprocess/managed_external_buffer.hpp | 17
trunk/boost/interprocess/managed_heap_memory.hpp | 13
trunk/boost/interprocess/managed_mapped_file.hpp | 15
trunk/boost/interprocess/managed_shared_memory.hpp | 22
trunk/boost/interprocess/managed_windows_shared_memory.hpp | 13
trunk/boost/interprocess/managed_xsi_shared_memory.hpp | 7
trunk/boost/interprocess/mapped_region.hpp | 6
trunk/boost/interprocess/mem_algo/detail/mem_algo_common.hpp | 131 ++--
trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp | 4
trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp | 185 +++---
trunk/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp | 255 ++++----
trunk/boost/interprocess/mem_algo/rbtree_best_fit.hpp | 614 ++++++++++++---------
trunk/boost/interprocess/mem_algo/simple_seq_fit.hpp | 4
trunk/boost/interprocess/offset_ptr.hpp | 244 ++++---
trunk/boost/interprocess/segment_manager.hpp | 144 ++--
trunk/boost/interprocess/shared_memory_object.hpp | 6
trunk/boost/interprocess/smart_ptr/shared_ptr.hpp | 8
trunk/boost/interprocess/smart_ptr/unique_ptr.hpp | 10
trunk/boost/interprocess/sync/file_lock.hpp | 6
trunk/boost/interprocess/sync/scoped_lock.hpp | 14
trunk/boost/interprocess/sync/sharable_lock.hpp | 10
trunk/boost/interprocess/sync/upgradable_lock.hpp | 10
trunk/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp | 11
trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp | 8
trunk/boost/interprocess/windows_shared_memory.hpp | 6
trunk/boost/interprocess/xsi_shared_memory.hpp | 6
84 files changed, 2236 insertions(+), 3089 deletions(-)
Modified: trunk/boost/interprocess/allocators/adaptive_pool.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/adaptive_pool.hpp (original)
+++ trunk/boost/interprocess/allocators/adaptive_pool.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -92,8 +92,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
typedef boost::interprocess::version_type<adaptive_pool_base, Version> version;
typedef boost::container::containers_detail::transform_multiallocation_chain
@@ -294,8 +294,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
//!Obtains adaptive_pool from
//!adaptive_pool
@@ -398,7 +398,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -424,7 +424,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
Modified: trunk/boost/interprocess/allocators/allocator.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/allocator.hpp (original)
+++ trunk/boost/interprocess/allocators/allocator.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -95,8 +95,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
typedef boost::interprocess::version_type<allocator, 2> version;
@@ -186,7 +186,7 @@
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
multiallocation_chain allocate_many
- (size_type elem_size, std::size_t num_elements)
+ (size_type elem_size, size_type num_elements)
{
return multiallocation_chain(mp_mngr->allocate_many(sizeof(T)*elem_size, num_elements));
}
@@ -224,7 +224,7 @@
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
multiallocation_chain allocate_individual
- (std::size_t num_elements)
+ (size_type num_elements)
{ return this->allocate_many(1, num_elements); }
//!Deallocates memory previously allocated with allocate_one().
Modified: trunk/boost/interprocess/allocators/cached_adaptive_pool.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/cached_adaptive_pool.hpp (original)
+++ trunk/boost/interprocess/allocators/cached_adaptive_pool.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -74,8 +74,10 @@
<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> other;
};
+ typedef typename base_t::size_type size_type;
+
cached_adaptive_pool_v1(SegmentManager *segment_mngr,
- std::size_t max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
+ size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
: base_t(segment_mngr, max_cached_nodes)
{}
@@ -174,8 +176,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
//!Obtains cached_adaptive_pool from
//!cached_adaptive_pool
@@ -278,7 +280,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -304,7 +306,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
@@ -320,11 +322,11 @@
void deallocate_individual(multiallocation_chain chain);
//!Sets the new max cached nodes value. This can provoke deallocations
//!if "newmax" is less than current cached nodes. Never throws
- void set_max_cached_nodes(std::size_t newmax);
+ void set_max_cached_nodes(size_type newmax);
//!Returns the max cached nodes parameter.
//!Never throws
- std::size_t get_max_cached_nodes() const;
+ size_type get_max_cached_nodes() const;
#endif
};
Modified: trunk/boost/interprocess/allocators/cached_node_allocator.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/cached_node_allocator.hpp (original)
+++ trunk/boost/interprocess/allocators/cached_node_allocator.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -69,8 +69,10 @@
<T2, SegmentManager, NodesPerBlock> other;
};
+ typedef typename base_t::size_type size_type;
+
cached_node_allocator_v1(SegmentManager *segment_mngr,
- std::size_t max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
+ size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
: base_t(segment_mngr, max_cached_nodes)
{}
@@ -116,6 +118,7 @@
public:
typedef boost::interprocess::version_type<cached_node_allocator, 2> version;
+ typedef typename base_t::size_type size_type;
template<class T2>
struct rebind
@@ -124,7 +127,7 @@
};
cached_node_allocator(SegmentManager *segment_mngr,
- std::size_t max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
+ size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES)
: base_t(segment_mngr, max_cached_nodes)
{}
@@ -145,8 +148,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename SegmentManager::size_type size_type;
+ typedef typename SegmentManager::difference_type difference_type;
//!Obtains cached_node_allocator from
//!cached_node_allocator
@@ -249,7 +252,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -275,7 +278,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
@@ -291,11 +294,11 @@
void deallocate_individual(multiallocation_chain it);
//!Sets the new max cached nodes value. This can provoke deallocations
//!if "newmax" is less than current cached nodes. Never throws
- void set_max_cached_nodes(std::size_t newmax);
+ void set_max_cached_nodes(size_type newmax);
//!Returns the max cached nodes parameter.
//!Never throws
- std::size_t get_max_cached_nodes() const;
+ size_type get_max_cached_nodes() const;
#endif
};
Modified: trunk/boost/interprocess/allocators/detail/adaptive_node_pool.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/detail/adaptive_node_pool.hpp (original)
+++ trunk/boost/interprocess/allocators/detail/adaptive_node_pool.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -56,12 +56,13 @@
private_adaptive_node_pool &operator=(const private_adaptive_node_pool &);
public:
- typedef SegmentManager segment_manager;
+ typedef SegmentManager segment_manager;
+ typedef typename base_t::size_type size_type;
- static const std::size_t nodes_per_block = NodesPerBlock;
+ static const size_type nodes_per_block = NodesPerBlock;
//Deprecated, use node_per_block
- static const std::size_t nodes_per_chunk = NodesPerBlock;
+ static const size_type nodes_per_chunk = NodesPerBlock;
//!Constructor from a segment manager. Never throws
private_adaptive_node_pool(segment_manager *segment_mngr)
Modified: trunk/boost/interprocess/allocators/detail/allocator_common.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/detail/allocator_common.hpp (original)
+++ trunk/boost/interprocess/allocators/detail/allocator_common.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -149,15 +149,16 @@
void_pointer void_pointer;
typedef typename pointer_to_other
<void_pointer, NodePool>::type node_pool_ptr;
- typedef typename NodePool::multiallocation_chain multiallocation_chain;
+ typedef typename NodePool::multiallocation_chain multiallocation_chain;
+ typedef typename NodePool::segment_manager::size_type size_type;
node_pool_ptr mp_node_pool;
multiallocation_chain m_cached_nodes;
- std::size_t m_max_cached_nodes;
+ size_type m_max_cached_nodes;
public:
typedef typename NodePool::segment_manager segment_manager;
- cache_impl(segment_manager *segment_mngr, std::size_t max_cached_nodes)
+ cache_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
: mp_node_pool(get_or_create_node_pool<NodePool>(segment_mngr))
, m_max_cached_nodes(max_cached_nodes)
{}
@@ -181,7 +182,7 @@
segment_manager *get_segment_manager() const
{ return mp_node_pool->get_segment_manager(); }
- std::size_t get_max_cached_nodes() const
+ size_type get_max_cached_nodes() const
{ return m_max_cached_nodes; }
void *cached_allocation()
@@ -195,10 +196,10 @@
return ret;
}
- multiallocation_chain cached_allocation(std::size_t n)
+ multiallocation_chain cached_allocation(size_type n)
{
multiallocation_chain chain;
- std::size_t count = n, allocated(0);
+ size_type count = n, allocated(0);
BOOST_TRY{
//If don't have any cached node, we have to get a new list of free nodes from the pool
while(!m_cached_nodes.empty() && count--){
@@ -250,7 +251,7 @@
//!Sets the new max cached nodes value. This can provoke deallocations
//!if "newmax" is less than current cached nodes. Never throws
- void set_max_cached_nodes(std::size_t newmax)
+ void set_max_cached_nodes(size_type newmax)
{
m_max_cached_nodes = newmax;
this->priv_deallocate_remaining_nodes();
@@ -275,13 +276,13 @@
}
//!Frees n cached nodes at once. Never throws
- void priv_deallocate_n_nodes(std::size_t n)
+ void priv_deallocate_n_nodes(size_type n)
{
//This only occurs if this allocator deallocate memory allocated
//with other equal allocator. Since the cache is full, and more
//deallocations are probably coming, we'll make some room in cache
//in a single, efficient multi node deallocation.
- std::size_t count(n);
+ size_type count(n);
typename multiallocation_chain::iterator it(m_cached_nodes.before_begin());
while(count--){
++it;
@@ -321,8 +322,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename SegmentManager::size_type size_type;
+ typedef typename SegmentManager::difference_type difference_type;
typedef boost::container::containers_detail::transform_multiallocation_chain
<typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
@@ -352,7 +353,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements)
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements)
{
return this->derived()->get_segment_manager()->allocate_many(sizeof(T)*elem_size, num_elements);
}
@@ -432,8 +433,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename SegmentManager::size_type size_type;
+ typedef typename SegmentManager::difference_type difference_type;
typedef boost::container::containers_detail::transform_multiallocation_chain
<typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
@@ -492,7 +493,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements)
+ multiallocation_chain allocate_individual(size_type num_elements)
{
typedef typename node_pool<0>::type node_pool_t;
node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
@@ -557,7 +558,7 @@
public:
enum { DEFAULT_MAX_CACHED_NODES = 64 };
- cached_allocator_impl(segment_manager *segment_mngr, std::size_t max_cached_nodes)
+ cached_allocator_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
: m_cache(segment_mngr, max_cached_nodes)
{}
@@ -587,12 +588,12 @@
//!Sets the new max cached nodes value. This can provoke deallocations
//!if "newmax" is less than current cached nodes. Never throws
- void set_max_cached_nodes(std::size_t newmax)
+ void set_max_cached_nodes(size_type newmax)
{ m_cache.set_max_cached_nodes(newmax); }
//!Returns the max cached nodes parameter.
//!Never throws
- std::size_t get_max_cached_nodes() const
+ size_type get_max_cached_nodes() const
{ return m_cache.get_max_cached_nodes(); }
//!Allocate memory for an array of count elements.
@@ -636,7 +637,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements)
+ multiallocation_chain allocate_individual(size_type num_elements)
{ return multiallocation_chain(this->m_cache.cached_allocation(num_elements)); }
//!Deallocates memory previously allocated with allocate_one().
@@ -708,6 +709,8 @@
segment_manager segment_manager;
typedef typename private_node_allocator_t::
multiallocation_chain multiallocation_chain;
+ typedef typename private_node_allocator_t::
+ size_type size_type;
private:
typedef typename segment_manager::mutex_family::mutex_type mutex_type;
@@ -742,7 +745,7 @@
/*
//!Allocates a singly linked list of n nodes ending in null pointer.
//!can throw boost::interprocess::bad_alloc
- void allocate_nodes(multiallocation_chain &nodes, std::size_t n)
+ void allocate_nodes(multiallocation_chain &nodes, size_type n)
{
//-----------------------
boost::interprocess::scoped_lock<mutex_type> guard(m_header);
@@ -752,7 +755,7 @@
*/
//!Allocates n nodes.
//!Can throw boost::interprocess::bad_alloc
- multiallocation_chain allocate_nodes(const std::size_t n)
+ multiallocation_chain allocate_nodes(const size_type n)
{
//-----------------------
boost::interprocess::scoped_lock<mutex_type> guard(m_header);
@@ -761,7 +764,7 @@
}
//!Deallocates a linked list of nodes ending in null pointer. Never throws
- void deallocate_nodes(multiallocation_chain &nodes, std::size_t num)
+ void deallocate_nodes(multiallocation_chain &nodes, size_type num)
{
//-----------------------
boost::interprocess::scoped_lock<mutex_type> guard(m_header);
@@ -799,7 +802,7 @@
}
//!Increments internal reference count and returns new count. Never throws
- std::size_t inc_ref_count()
+ size_type inc_ref_count()
{
//-----------------------
boost::interprocess::scoped_lock<mutex_type> guard(m_header);
@@ -808,7 +811,7 @@
}
//!Decrements internal reference count and returns new count. Never throws
- std::size_t dec_ref_count()
+ size_type dec_ref_count()
{
//-----------------------
boost::interprocess::scoped_lock<mutex_type> guard(m_header);
@@ -840,7 +843,7 @@
//!the mutex type to allow EBO when using null_mutex
struct header_t : mutex_type
{
- std::size_t m_usecount; //Number of attached allocators
+ size_type m_usecount; //Number of attached allocators
header_t()
: m_usecount(0) {}
Modified: trunk/boost/interprocess/allocators/detail/node_pool.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/detail/node_pool.hpp (original)
+++ trunk/boost/interprocess/allocators/detail/node_pool.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -55,11 +55,12 @@
private_node_pool &operator=(const private_node_pool &);
public:
- typedef SegmentManager segment_manager;
+ typedef SegmentManager segment_manager;
+ typedef typename base_t::size_type size_type;
- static const std::size_t nodes_per_block = NodesPerBlock;
+ static const size_type nodes_per_block = NodesPerBlock;
//Deprecated, use nodes_per_block
- static const std::size_t nodes_per_chunk = NodesPerBlock;
+ static const size_type nodes_per_chunk = NodesPerBlock;
//!Constructor from a segment manager. Never throws
private_node_pool(segment_manager *segment_mngr)
Modified: trunk/boost/interprocess/allocators/node_allocator.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/node_allocator.hpp (original)
+++ trunk/boost/interprocess/allocators/node_allocator.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -89,8 +89,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
typedef boost::interprocess::version_type<node_allocator_base, Version> version;
typedef boost::container::containers_detail::transform_multiallocation_chain
@@ -279,8 +279,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
//!Obtains node_allocator from
//!node_allocator
@@ -383,7 +383,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -409,7 +409,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
Modified: trunk/boost/interprocess/allocators/private_adaptive_pool.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/private_adaptive_pool.hpp (original)
+++ trunk/boost/interprocess/allocators/private_adaptive_pool.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -90,8 +90,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::size_type difference_type;
typedef boost::interprocess::version_type
<private_adaptive_pool_base, Version> version;
typedef boost::container::containers_detail::transform_multiallocation_chain
@@ -293,8 +293,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
//!Obtains private_adaptive_pool from
//!private_adaptive_pool
@@ -398,7 +398,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -424,7 +424,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
Modified: trunk/boost/interprocess/allocators/private_node_allocator.hpp
==============================================================================
--- trunk/boost/interprocess/allocators/private_node_allocator.hpp (original)
+++ trunk/boost/interprocess/allocators/private_node_allocator.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -84,8 +84,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manager::difference_type difference_type;
typedef boost::interprocess::version_type
<private_node_allocator_base, Version> version;
typedef boost::container::containers_detail::transform_multiallocation_chain
@@ -269,8 +269,8 @@
<value_type>::type reference;
typedef typename detail::add_reference
<const value_type>::type const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef typename segment_manager::size_type size_type;
+ typedef typename segment_manage::difference_type difference_type;
//!Obtains private_node_allocator from
//!private_node_allocator
@@ -374,7 +374,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. The elements must be deallocated
//!with deallocate(...)
- multiallocation_chain allocate_many(size_type elem_size, std::size_t num_elements);
+ multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
//!Allocates n_elements elements, each one of size elem_sizes[i]in a
//!contiguous block
@@ -400,7 +400,7 @@
//!preferred_elements. The number of actually allocated elements is
//!will be assigned to received_size. Memory allocated with this function
//!must be deallocated only with deallocate_one().
- multiallocation_chain allocate_individual(std::size_t num_elements);
+ multiallocation_chain allocate_individual(size_type num_elements);
//!Deallocates memory previously allocated with allocate_one().
//!You should never use deallocate_one to deallocate memory allocated
Modified: trunk/boost/interprocess/containers/container/deque.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/deque.hpp (original)
+++ trunk/boost/interprocess/containers/container/deque.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -35,7 +35,8 @@
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -82,7 +83,8 @@
typedef typename Alloc::const_pointer val_alloc_cptr;
typedef typename Alloc::reference val_alloc_ref;
typedef typename Alloc::const_reference val_alloc_cref;
- typedef typename Alloc::value_type val_alloc_diff;
+ typedef typename Alloc::difference_type val_alloc_diff;
+ typedef typename Alloc::size_type val_alloc_size;
typedef typename Alloc::template rebind
<typename Alloc::pointer>::other ptr_alloc_t;
typedef typename ptr_alloc_t::value_type ptr_alloc_val;
@@ -93,6 +95,7 @@
typedef typename Alloc::template
rebind<T>::other allocator_type;
typedef allocator_type stored_allocator_type;
+ typedef val_alloc_size size_type;
protected:
@@ -100,7 +103,7 @@
typedef typename Alloc::template
rebind<typename Alloc::pointer>::other map_allocator_type;
- static std::size_t s_buffer_size() { return deque_buf_size(sizeof(T)); }
+ static size_type s_buffer_size() { return deque_buf_size(sizeof(T)); }
val_alloc_ptr priv_allocate_node()
{ return this->alloc().allocate(s_buffer_size()); }
@@ -108,10 +111,10 @@
void priv_deallocate_node(val_alloc_ptr p)
{ this->alloc().deallocate(p, s_buffer_size()); }
- ptr_alloc_ptr priv_allocate_map(std::size_t n)
+ ptr_alloc_ptr priv_allocate_map(size_type n)
{ return this->ptr_alloc().allocate(n); }
- void priv_deallocate_map(ptr_alloc_ptr p, std::size_t n)
+ void priv_deallocate_map(ptr_alloc_ptr p, size_type n)
{ this->ptr_alloc().deallocate(p, n); }
public:
@@ -145,14 +148,13 @@
val_alloc_cptr, val_alloc_cref>
{
public:
- static std::size_t s_buffer_size() { return deque_base<T, Alloc>::s_buffer_size(); }
+ static size_type s_buffer_size() { return deque_base<T, Alloc>::s_buffer_size(); }
typedef std::random_access_iterator_tag iterator_category;
typedef val_alloc_val value_type;
typedef val_alloc_cptr pointer;
typedef val_alloc_cref reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef val_alloc_diff difference_type;
typedef ptr_alloc_ptr index_pointer;
typedef const_iterator self_t;
@@ -282,7 +284,7 @@
this->m_last = this->m_first + difference_type(this->s_buffer_size());
}
- friend const_iterator operator+(std::ptrdiff_t n, const const_iterator& x)
+ friend const_iterator operator+(difference_type n, const const_iterator& x)
{ return x + n; }
};
@@ -294,8 +296,7 @@
typedef val_alloc_val value_type;
typedef val_alloc_ptr pointer;
typedef val_alloc_ref reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef val_alloc_diff difference_type;
typedef ptr_alloc_ptr index_pointer;
typedef const_iterator self_t;
@@ -351,7 +352,7 @@
{ return static_cast<const const_iterator&>(*this) - right; }
};
- deque_base(const allocator_type& a, std::size_t num_elements)
+ deque_base(const allocator_type& a, size_type num_elements)
: members_(a)
{ this->priv_initialize_map(num_elements); }
@@ -372,12 +373,12 @@
protected:
- void priv_initialize_map(std::size_t num_elements)
+ void priv_initialize_map(size_type num_elements)
{
// if(num_elements){
- std::size_t num_nodes = num_elements / s_buffer_size() + 1;
+ size_type num_nodes = num_elements / s_buffer_size() + 1;
- this->members_.m_map_size = containers_detail::max_value((std::size_t) InitialMapSize, num_nodes + 2);
+ this->members_.m_map_size = containers_detail::max_value((size_type) InitialMapSize, num_nodes + 2);
this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);
ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
@@ -436,7 +437,7 @@
{}
ptr_alloc_ptr m_map;
- std::size_t m_map_size;
+ typename allocator_type::size_type m_map_size;
iterator m_start;
iterator m_finish;
} members_;
@@ -461,8 +462,6 @@
class deque : protected deque_base<T, Alloc>
{
/// @cond
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
typedef deque_base<T, Alloc> Base;
public: // Basic types
@@ -471,6 +470,9 @@
typedef typename Alloc::const_pointer val_alloc_cptr;
typedef typename Alloc::reference val_alloc_ref;
typedef typename Alloc::const_reference val_alloc_cref;
+ typedef typename Alloc::size_type val_alloc_size;
+ typedef typename Alloc::difference_type val_alloc_diff;
+
typedef typename Alloc::template
rebind<val_alloc_ptr>::other ptr_alloc_t;
typedef typename ptr_alloc_t::value_type ptr_alloc_val;
@@ -485,9 +487,8 @@
typedef val_alloc_cptr const_pointer;
typedef val_alloc_ref reference;
typedef val_alloc_cref const_reference;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
-
+ typedef val_alloc_size size_type;
+ typedef val_alloc_diff difference_type;
typedef typename Base::allocator_type allocator_type;
public: // Iterators
@@ -499,13 +500,13 @@
/// @cond
private: // Internal typedefs
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(deque)
+ BOOST_COPYABLE_AND_MOVABLE(deque)
typedef ptr_alloc_ptr index_pointer;
- static std::size_t s_buffer_size()
+ static size_type s_buffer_size()
{ return Base::s_buffer_size(); }
typedef containers_detail::advanced_insert_aux_int<value_type, iterator> advanced_insert_aux_int_t;
typedef repeat_iterator<T, difference_type> r_iterator;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<r_iterator> move_it;
+ typedef boost::move_iterator<r_iterator> move_it;
/// @endcond
@@ -595,7 +596,7 @@
}
}
- deque(BOOST_MOVE_MACRO_RV_REF(deque) mx)
+ deque(BOOST_RV_REF(deque) mx)
: Base(mx.alloc())
{ this->swap(mx); }
@@ -612,7 +613,7 @@
: Base(a)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_initialize_dispatch(first, last, Result());
}
@@ -622,7 +623,7 @@
priv_destroy_range(this->members_.m_start, this->members_.m_finish);
}
- deque& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(deque) x)
+ deque& operator= (BOOST_COPY_ASSIGN_REF(deque) x)
{
const size_type len = size();
if (&x != this) {
@@ -637,7 +638,7 @@
return *this;
}
- deque& operator= (BOOST_MOVE_MACRO_RV_REF(deque) x)
+ deque& operator= (BOOST_RV_REF(deque) x)
{
this->clear();
this->swap(x);
@@ -659,55 +660,51 @@
void assign(InpIt first, InpIt last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_assign_dispatch(first, last, Result());
}
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_back(T &x) { push_back(const_cast<const T &>(x)); }
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! <b>Effects</b>: Inserts a copy of x at the end of the deque.
+ //!
+ //! <b>Throws</b>: If memory allocation throws or
+ //! T's copy constructor throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+ void push_back(const T &x);
- template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { return priv_push_back(u); }
+ //! <b>Effects</b>: Constructs a new element in the end of the deque
+ //! and moves the resources of mx to this new element.
+ //!
+ //! <b>Throws</b>: If memory allocation throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
#endif
- void push_back(insert_const_ref_type t)
- { return priv_push_back(t); }
-
- void push_back(BOOST_MOVE_MACRO_RV_REF(value_type) t)
- {
- if(this->priv_push_back_simple_available()){
- new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
- this->priv_push_back_simple_commit();
- }
- else{
- this->priv_insert_aux(cend(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
- }
- }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_front(T &x) { push_front(const_cast<const T &>(x)); }
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! <b>Effects</b>: Inserts a copy of x at the end of the deque.
+ //!
+ //! <b>Throws</b>: If memory allocation throws or
+ //! T's copy constructor throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+ void push_front(const T &x);
- template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { return priv_push_front(u); }
+ //! <b>Effects</b>: Constructs a new element in the end of the deque
+ //! and moves the resources of mx to this new element.
+ //!
+ //! <b>Throws</b>: If memory allocation throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+ void push_front(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_front, T, void, priv_push_front)
#endif
- void push_front(insert_const_ref_type t)
- { return priv_push_front(t); }
-
- void push_front(BOOST_MOVE_MACRO_RV_REF(value_type) t)
- {
- if(this->priv_push_front_simple_available()){
- new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(t));
- this->priv_push_front_simple_commit();
- }
- else{
- this->priv_insert_aux(cbegin(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
- }
- }
-
void pop_back()
{
if (this->members_.m_finish.m_cur != this->members_.m_finish.m_first) {
@@ -728,35 +725,30 @@
this->priv_pop_front_aux();
}
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x)
- { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
+ //! <b>Requires</b>: position must be a valid iterator of *this.
+ //!
+ //! <b>Effects</b>: Insert a copy of x before position.
+ //!
+ //! <b>Throws</b>: If memory allocation throws or x's copy constructor throws.
+ //!
+ //! <b>Complexity</b>: If position is end(), amortized constant time
+ //! Linear time otherwise.
+ iterator insert(const_iterator position, const T &x);
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) mx)
- {
- if (position == cbegin()) {
- this->push_front(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
- return begin();
- }
- else if (position == cend()) {
- this->push_back(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx));
- return(end()-1);
- }
- else {
- //Just call more general insert(pos, size, value) and return iterator
- size_type n = position - begin();
- this->priv_insert_aux(position, move_it(r_iterator(mx, 1)), move_it(r_iterator()));
- return iterator(this->begin() + n);
- }
- }
+ //! <b>Requires</b>: position must be a valid iterator of *this.
+ //!
+ //! <b>Effects</b>: Insert a new element before position with mx's resources.
+ //!
+ //! <b>Throws</b>: If memory allocation throws.
+ //!
+ //! <b>Complexity</b>: If position is end(), amortized constant time
+ //! Linear time otherwise.
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif
void insert(const_iterator pos, size_type n, const value_type& x)
{ this->priv_fill_insert(pos, n, x); }
@@ -766,7 +758,7 @@
void insert(const_iterator pos, InpIt first, InpIt last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_insert_dispatch(pos, first, last, Result());
}
@@ -777,12 +769,12 @@
void emplace_back(Args&&... args)
{
if(this->priv_push_back_simple_available()){
- new(this->priv_push_back_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new(this->priv_push_back_simple_pos())value_type(boost::forward<Args>(args)...);
this->priv_push_back_simple_commit();
}
else{
typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
this->priv_insert_aux_impl(this->cend(), 1, proxy);
}
}
@@ -791,12 +783,12 @@
void emplace_front(Args&&... args)
{
if(this->priv_push_front_simple_available()){
- new(this->priv_push_front_simple_pos())value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new(this->priv_push_front_simple_pos())value_type(boost::forward<Args>(args)...);
this->priv_push_front_simple_commit();
}
else{
typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
this->priv_insert_aux_impl(this->cbegin(), 1, proxy);
}
}
@@ -805,17 +797,17 @@
iterator emplace(const_iterator p, Args&&... args)
{
if(p == this->cbegin()){
- this->emplace_front(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace_front(boost::forward<Args>(args)...);
return this->begin();
}
else if(p == this->cend()){
- this->emplace_back(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace_back(boost::forward<Args>(args)...);
return (this->end()-1);
}
else{
size_type n = p - this->cbegin();
typedef containers_detail::advanced_insert_aux_emplace<T, iterator, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(boost::forward<Args>(args)...);
this->priv_insert_aux_impl(p, 1, proxy);
return iterator(this->begin() + n);
}
@@ -953,11 +945,11 @@
++next;
difference_type index = pos - this->members_.m_start;
if (size_type(index) < (this->size() >> 1)) {
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(begin(), iterator(pos), iterator(next));
+ boost::move_backward(begin(), iterator(pos), iterator(next));
pop_front();
}
else {
- BOOST_CONTAINER_MOVE_NAMESPACE::move(iterator(next), end(), iterator(pos));
+ boost::move(iterator(next), end(), iterator(pos));
pop_back();
}
return this->members_.m_start + index;
@@ -973,7 +965,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_CONTAINER_MOVE_NAMESPACE::move_backward(begin(), iterator(first), iterator(last));
+ boost::move_backward(begin(), iterator(first), iterator(last));
iterator new_start = this->members_.m_start + n;
if(!Base::traits_t::trivial_dctr_after_move)
this->priv_destroy_range(this->members_.m_start, new_start);
@@ -981,7 +973,7 @@
this->members_.m_start = new_start;
}
else {
- BOOST_CONTAINER_MOVE_NAMESPACE::move(iterator(last), end(), iterator(first));
+ boost::move(iterator(last), end(), iterator(first));
iterator new_finish = this->members_.m_finish - n;
if(!Base::traits_t::trivial_dctr_after_move)
this->priv_destroy_range(new_finish, this->members_.m_finish);
@@ -1032,6 +1024,24 @@
}
}
+ iterator priv_insert(const_iterator position, BOOST_RV_REF(value_type) mx)
+ {
+ if (position == cbegin()) {
+ this->push_front(boost::move(mx));
+ return begin();
+ }
+ else if (position == cend()) {
+ this->push_back(boost::move(mx));
+ return(end()-1);
+ }
+ else {
+ //Just call more general insert(pos, size, value) and return iterator
+ size_type n = position - begin();
+ this->priv_insert_aux(position, move_it(r_iterator(mx, 1)), move_it(r_iterator()));
+ return iterator(this->begin() + n);
+ }
+ }
+
void priv_push_front(const value_type &t)
{
if(this->priv_push_front_simple_available()){
@@ -1043,6 +1053,17 @@
}
}
+ void priv_push_front(BOOST_RV_REF(value_type) t)
+ {
+ if(this->priv_push_front_simple_available()){
+ new(this->priv_push_front_simple_pos())value_type(boost::move(t));
+ this->priv_push_front_simple_commit();
+ }
+ else{
+ this->priv_insert_aux(cbegin(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
+ }
+ }
+
void priv_push_back(const value_type &t)
{
if(this->priv_push_back_simple_available()){
@@ -1054,6 +1075,16 @@
}
}
+ void priv_push_back(BOOST_RV_REF(T) t)
+ {
+ if(this->priv_push_back_simple_available()){
+ new(this->priv_push_back_simple_pos())value_type(boost::move(t));
+ this->priv_push_back_simple_commit();
+ }
+ else{
+ this->priv_insert_aux(cend(), move_it(r_iterator(t, 1)), move_it(r_iterator()));
+ }
+ }
bool priv_push_back_simple_available() const
{
@@ -1087,7 +1118,7 @@
void priv_insert_aux(const_iterator pos, InpIt first, InpIt last, std::input_iterator_tag)
{
for(;first != last; ++first){
- this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
+ this->insert(pos, boost::move(value_type(*first)));
}
}
@@ -1215,9 +1246,9 @@
pos = this->members_.m_start + elemsbefore;
if (elemsbefore >= difference_type(n)) {
iterator start_n = this->members_.m_start + difference_type(n);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(this->members_.m_start, start_n, new_start);
+ ::boost::uninitialized_move(this->members_.m_start, start_n, new_start);
this->members_.m_start = new_start;
- BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
+ boost::move(start_n, pos, old_start);
interf.copy_all_to(pos - difference_type(n));
}
else {
@@ -1225,7 +1256,7 @@
iterator mid_start = old_start - mid_count;
interf.uninitialized_copy_some_and_update(mid_start, mid_count, true);
this->members_.m_start = mid_start;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
this->members_.m_start = new_start;
interf.copy_all_to(old_start);
}
@@ -1238,15 +1269,15 @@
pos = this->members_.m_finish - elemsafter;
if (elemsafter >= difference_type(n)) {
iterator finish_n = this->members_.m_finish - difference_type(n);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
+ ::boost::uninitialized_move(finish_n, this->members_.m_finish, this->members_.m_finish);
this->members_.m_finish = new_finish;
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, finish_n, old_finish);
+ boost::move_backward(pos, finish_n, old_finish);
interf.copy_all_to(pos);
}
else {
interf.uninitialized_copy_some_and_update(old_finish, elemsafter, false);
this->members_.m_finish += n-elemsafter;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, old_finish, this->members_.m_finish);
+ ::boost::uninitialized_move(pos, old_finish, this->members_.m_finish);
this->members_.m_finish = new_finish;
interf.copy_all_to(pos);
}
@@ -1306,10 +1337,10 @@
++cur_node) {
FwdIt mid = first;
std::advance(mid, this->s_buffer_size());
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, mid, *cur_node);
+ ::boost::uninitialized_copy_or_move(first, mid, *cur_node);
first = mid;
}
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, last, this->members_.m_finish.m_first);
+ ::boost::uninitialized_copy_or_move(first, last, this->members_.m_finish.m_first);
}
BOOST_CATCH(...){
this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node));
@@ -1400,9 +1431,9 @@
new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2
+ (add_at_front ? nodes_to_add : 0);
if (new_nstart < this->members_.m_start.m_node)
- BOOST_CONTAINER_MOVE_NAMESPACE::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
else
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward
+ boost::move_backward
(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
}
else {
@@ -1412,7 +1443,7 @@
index_pointer new_map = this->priv_allocate_map(new_map_size);
new_nstart = new_map + (new_map_size - new_num_nodes) / 2
+ (add_at_front ? nodes_to_add : 0);
- BOOST_CONTAINER_MOVE_NAMESPACE::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
+ boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
this->members_.m_map = new_map;
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -33,15 +33,16 @@
namespace container {
namespace containers_detail {
-struct hdr_offset_holder
+template<class size_type>
+struct hdr_offset_holder_t
{
- hdr_offset_holder(std::size_t offset = 0)
+ hdr_offset_holder_t(size_type offset = 0)
: hdr_offset(offset)
{}
- std::size_t hdr_offset;
+ size_type hdr_offset;
};
-template<class VoidPointer>
+template<class VoidPointer, class SizeType>
struct adaptive_pool_types
{
typedef VoidPointer void_pointer;
@@ -50,6 +51,8 @@
, bi::optimize_size<true>
, bi::constant_time_size<false>
, bi::link_mode<bi::normal_link> >::type multiset_hook_t;
+
+ typedef hdr_offset_holder_t<SizeType> hdr_offset_holder;
struct block_info_t
:
@@ -77,23 +80,23 @@
<block_info_t, bi::base_hook<multiset_hook_t> >::type block_multiset_t;
};
-
-inline std::size_t calculate_alignment
- ( std::size_t overhead_percent, std::size_t real_node_size
- , std::size_t hdr_size, std::size_t hdr_offset_size, std::size_t payload_per_allocation)
+template<class size_type>
+inline size_type calculate_alignment
+ ( size_type overhead_percent, size_type real_node_size
+ , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
{
//to-do: handle real_node_size != node_size
- const std::size_t divisor = overhead_percent*real_node_size;
- const std::size_t dividend = hdr_offset_size*100;
- std::size_t elements_per_subblock = (dividend - 1)/divisor + 1;
- std::size_t candidate_power_of_2 =
+ const size_type divisor = overhead_percent*real_node_size;
+ const size_type dividend = hdr_offset_size*100;
+ size_type elements_per_subblock = (dividend - 1)/divisor + 1;
+ size_type candidate_power_of_2 =
upper_power_of_2(elements_per_subblock*real_node_size + hdr_offset_size);
bool overhead_satisfied = false;
//Now calculate the wors-case overhead for a subblock
- const std::size_t max_subblock_overhead = hdr_size + payload_per_allocation;
+ const size_type max_subblock_overhead = hdr_size + payload_per_allocation;
while(!overhead_satisfied){
elements_per_subblock = (candidate_power_of_2 - max_subblock_overhead)/real_node_size;
- const std::size_t overhead_size = candidate_power_of_2 - elements_per_subblock*real_node_size;
+ const size_type overhead_size = candidate_power_of_2 - elements_per_subblock*real_node_size;
if(overhead_size*100/candidate_power_of_2 < overhead_percent){
overhead_satisfied = true;
}
@@ -104,22 +107,23 @@
return candidate_power_of_2;
}
+template<class size_type>
inline void calculate_num_subblocks
- (std::size_t alignment, std::size_t real_node_size, std::size_t elements_per_block
- , std::size_t &num_subblocks, std::size_t &real_num_node, std::size_t overhead_percent
- , std::size_t hdr_size, std::size_t hdr_offset_size, std::size_t payload_per_allocation)
+ (size_type alignment, size_type real_node_size, size_type elements_per_block
+ , size_type &num_subblocks, size_type &real_num_node, size_type overhead_percent
+ , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
{
- std::size_t elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
- std::size_t possible_num_subblock = (elements_per_block - 1)/elements_per_subblock + 1;
- std::size_t hdr_subblock_elements = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+ size_type elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
+ size_type possible_num_subblock = (elements_per_block - 1)/elements_per_subblock + 1;
+ size_type hdr_subblock_elements = (alignment - hdr_size - payload_per_allocation)/real_node_size;
while(((possible_num_subblock-1)*elements_per_subblock + hdr_subblock_elements) < elements_per_block){
++possible_num_subblock;
}
elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
bool overhead_satisfied = false;
while(!overhead_satisfied){
- const std::size_t total_data = (elements_per_subblock*(possible_num_subblock-1) + hdr_subblock_elements)*real_node_size;
- const std::size_t total_size = alignment*possible_num_subblock;
+ const size_type total_data = (elements_per_subblock*(possible_num_subblock-1) + hdr_subblock_elements)*real_node_size;
+ const size_type total_size = alignment*possible_num_subblock;
if((total_size - total_data)*100/total_size < overhead_percent){
overhead_satisfied = true;
}
@@ -141,7 +145,8 @@
typedef private_adaptive_node_pool_impl this_type;
typedef typename SegmentManagerBase::void_pointer void_pointer;
- static const std::size_t PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
+ static const typename SegmentManagerBase::
+ size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
typedef bool_<AlignOnly> IsAlignOnly;
typedef true_ AlignOnlyTrue;
typedef false_ AlignOnlyFalse;
@@ -150,15 +155,17 @@
typedef typename node_slist<void_pointer>::node_t node_t;
typedef typename node_slist<void_pointer>::node_slist_t free_nodes_t;
typedef typename SegmentManagerBase::multiallocation_chain multiallocation_chain;
+ typedef typename SegmentManagerBase::size_type size_type;
private:
- typedef typename adaptive_pool_types<void_pointer>::block_info_t block_info_t;
- typedef typename adaptive_pool_types<void_pointer>::block_multiset_t block_multiset_t;
- typedef typename block_multiset_t::iterator block_iterator;
-
- static const std::size_t MaxAlign = alignment_of<node_t>::value;
- static const std::size_t HdrSize = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
- static const std::size_t HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::block_info_t block_info_t;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::block_multiset_t block_multiset_t;
+ typedef typename block_multiset_t::iterator block_iterator;
+ typedef typename adaptive_pool_types<void_pointer, size_type>::hdr_offset_holder hdr_offset_holder;
+
+ static const size_type MaxAlign = alignment_of<node_t>::value;
+ static const size_type HdrSize = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
+ static const size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
public:
@@ -168,20 +175,20 @@
//!Constructor from a segment manager. Never throws
private_adaptive_node_pool_impl
( segment_manager_base_type *segment_mngr_base
- , std::size_t node_size
- , std::size_t nodes_per_block
- , std::size_t max_free_blocks
+ , size_type node_size
+ , size_type nodes_per_block
+ , size_type max_free_blocks
, unsigned char overhead_percent
)
: m_max_free_blocks(max_free_blocks)
- , m_real_node_size(lcm(node_size, std::size_t(alignment_of<node_t>::value)))
+ , m_real_node_size(lcm(node_size, size_type(alignment_of<node_t>::value)))
//Round the size to a power of two value.
//This is the total memory size (including payload) that we want to
//allocate from the general-purpose allocator
, m_real_block_alignment
(AlignOnly ?
upper_power_of_2(HdrSize + m_real_node_size*nodes_per_block) :
- calculate_alignment( overhead_percent, m_real_node_size
+ calculate_alignment( (size_type)overhead_percent, m_real_node_size
, HdrSize, HdrOffsetSize, PayloadPerAllocation))
//This is the real number of nodes per block
, m_num_subblocks(0)
@@ -198,7 +205,7 @@
, nodes_per_block
, m_num_subblocks
, m_real_num_node
- , overhead_percent
+ , (size_type)overhead_percent
, HdrSize
, HdrOffsetSize
, PayloadPerAllocation);
@@ -209,7 +216,7 @@
~private_adaptive_node_pool_impl()
{ priv_clear(); }
- std::size_t get_real_num_node() const
+ size_type get_real_num_node() const
{ return m_real_num_node; }
//!Returns the segment manager. Never throws
@@ -243,10 +250,10 @@
//!Allocates n nodes.
//!Can throw
- multiallocation_chain allocate_nodes(const std::size_t n)
+ multiallocation_chain allocate_nodes(const size_type n)
{
multiallocation_chain chain;
- std::size_t i = 0;
+ size_type i = 0;
try{
priv_invariants();
while(i != n){
@@ -255,12 +262,12 @@
priv_alloc_block(((n - i) - 1)/m_real_num_node + 1);
}
free_nodes_t &free_nodes = m_block_multiset.begin()->free_nodes;
- const std::size_t free_nodes_count_before = free_nodes.size();
+ const size_type free_nodes_count_before = free_nodes.size();
if(free_nodes_count_before == m_real_num_node){
--m_totally_free_blocks;
}
- const std::size_t num_elems = ((n-i) < free_nodes_count_before) ? (n-i) : free_nodes_count_before;
- for(std::size_t j = 0; j != num_elems; ++j){
+ const size_type num_elems = ((n-i) < free_nodes_count_before) ? (n-i) : free_nodes_count_before;
+ for(size_type j = 0; j != num_elems; ++j){
void *new_node = &free_nodes.front();
free_nodes.pop_front();
chain.push_back(new_node);
@@ -273,11 +280,11 @@
}
}
catch(...){
- this->deallocate_nodes(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
+ this->deallocate_nodes(boost::move(chain));
throw;
}
priv_invariants();
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
+ return boost::move(chain);
}
//!Deallocates a linked list of nodes. Never throws
@@ -292,10 +299,10 @@
void deallocate_free_blocks()
{ this->priv_deallocate_free_blocks(0); }
- std::size_t num_free_nodes()
+ size_type num_free_nodes()
{
typedef typename block_multiset_t::const_iterator citerator;
- std::size_t count = 0;
+ size_type count = 0;
citerator it (m_block_multiset.begin()), itend(m_block_multiset.end());
for(; it != itend; ++it){
count += it->free_nodes.size();
@@ -319,7 +326,7 @@
{ this->priv_deallocate_free_blocks(0); }
private:
- void priv_deallocate_free_blocks(std::size_t max_free_blocks)
+ void priv_deallocate_free_blocks(size_type max_free_blocks)
{
priv_invariants();
//Now check if we've reached the free nodes limit
@@ -337,7 +344,7 @@
}
}
- void priv_reinsert_nodes_in_block(multiallocation_chain &chain, std::size_t n)
+ void priv_reinsert_nodes_in_block(multiallocation_chain &chain, size_type n)
{
block_iterator block_it(m_block_multiset.end());
while(n--){
@@ -355,7 +362,7 @@
++next_block;
//Cache the free nodes from the block
- std::size_t this_block_free_nodes = this_block->free_nodes.size();
+ size_type this_block_free_nodes = this_block->free_nodes.size();
if(this_block_free_nodes == 1){
m_block_multiset.insert(m_block_multiset.begin(), *block_info);
@@ -364,7 +371,7 @@
block_iterator next_block(this_block);
++next_block;
if(next_block != block_it){
- std::size_t next_free_nodes = next_block->free_nodes.size();
+ size_type next_free_nodes = next_block->free_nodes.size();
if(this_block_free_nodes > next_free_nodes){
//Now move the block to the new position
m_block_multiset.erase(this_block);
@@ -386,7 +393,7 @@
//We take the first free node the multiset can't be empty
free_nodes_t &free_nodes = m_block_multiset.begin()->free_nodes;
node_t *first_node = &free_nodes.front();
- const std::size_t free_nodes_count = free_nodes.size();
+ const size_type free_nodes_count = free_nodes.size();
BOOST_ASSERT(0 != free_nodes_count);
free_nodes.pop_front();
if(free_nodes_count == 1){
@@ -415,7 +422,7 @@
private:
void do_destroy(typename block_multiset_t::pointer to_deallocate, AlignOnlyTrue)
{
- std::size_t free_nodes = to_deallocate->free_nodes.size();
+ size_type free_nodes = to_deallocate->free_nodes.size();
(void)free_nodes;
BOOST_ASSERT(free_nodes == mp_impl->m_real_num_node);
mp_impl->mp_segment_mngr_base->deallocate(to_deallocate);
@@ -423,7 +430,7 @@
void do_destroy(typename block_multiset_t::pointer to_deallocate, AlignOnlyFalse)
{
- std::size_t free_nodes = to_deallocate->free_nodes.size();
+ size_type free_nodes = to_deallocate->free_nodes.size();
(void)free_nodes;
BOOST_ASSERT(free_nodes == mp_impl->m_real_num_node);
BOOST_ASSERT(0 == to_deallocate->hdr_offset);
@@ -447,7 +454,7 @@
for(++it; it != itend; ++it){
block_iterator prev(it);
--prev;
- std::size_t sp = prev->free_nodes.size(),
+ size_type sp = prev->free_nodes.size(),
si = it->free_nodes.size();
BOOST_ASSERT(sp <= si);
(void)sp; (void)si;
@@ -456,7 +463,7 @@
//Check that the total free nodes are correct
it = m_block_multiset.begin();
itend = m_block_multiset.end();
- std::size_t total_free_nodes = 0;
+ size_type total_free_nodes = 0;
for(; it != itend; ++it){
total_free_nodes += it->free_nodes.size();
}
@@ -476,9 +483,9 @@
it = m_block_multiset.begin();
for(; it != itend; ++it){
hdr_offset_holder *hdr_off_holder = priv_first_subblock_from_block(&*it);
- for(std::size_t i = 0, max = m_num_subblocks; i < max; ++i){
- BOOST_ASSERT(hdr_off_holder->hdr_offset == std::size_t(reinterpret_cast<char*>(&*it)- reinterpret_cast<char*>(hdr_off_holder)));
- BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
+ for(size_type i = 0, max = m_num_subblocks; i < max; ++i){
+ BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(&*it)- reinterpret_cast<char*>(hdr_off_holder)));
+ BOOST_ASSERT(0 == ((size_type)hdr_off_holder & (m_real_block_alignment - 1)));
BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
hdr_off_holder = reinterpret_cast<hdr_offset_holder *>(reinterpret_cast<char*>(hdr_off_holder) + m_real_block_alignment);
}
@@ -495,7 +502,7 @@
#ifndef NDEBUG
block_iterator it = m_block_multiset.begin();
block_iterator itend = m_block_multiset.end();
- std::size_t num_free_nodes = 0;
+ size_type num_free_nodes = 0;
for(; it != itend; ++it){
//Check for memory leak
BOOST_ASSERT(it->free_nodes.size() == m_real_num_node);
@@ -512,7 +519,7 @@
block_info_t *priv_block_from_node(void *node, AlignOnlyFalse) const
{
hdr_offset_holder *hdr_off_holder =
- reinterpret_cast<hdr_offset_holder*>((std::size_t)node & std::size_t(~(m_real_block_alignment - 1)));
+ reinterpret_cast<hdr_offset_holder*>((std::size_t)node & size_type(~(m_real_block_alignment - 1)));
BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
block_info_t *block = reinterpret_cast<block_info_t *>
@@ -533,17 +540,17 @@
{
hdr_offset_holder *hdr_off_holder = reinterpret_cast<hdr_offset_holder*>
(reinterpret_cast<char*>(block) - (m_num_subblocks-1)*m_real_block_alignment);
- BOOST_ASSERT(hdr_off_holder->hdr_offset == std::size_t(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
- BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
+ BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
+ BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
return hdr_off_holder;
}
//!Allocates a several blocks of nodes. Can throw
- void priv_alloc_block(std::size_t n, AlignOnlyTrue)
+ void priv_alloc_block(size_type n, AlignOnlyTrue)
{
- std::size_t real_block_size = m_real_block_alignment - PayloadPerAllocation;
- for(std::size_t i = 0; i != n; ++i){
+ size_type real_block_size = m_real_block_alignment - PayloadPerAllocation;
+ for(size_type i = 0; i != n; ++i){
//We allocate a new NodeBlock and put it the last
//element of the tree
char *mem_address = static_cast<char*>
@@ -557,20 +564,20 @@
//We initialize all Nodes in Node Block to insert
//them in the free Node list
typename free_nodes_t::iterator prev_insert_pos = c_info->free_nodes.before_begin();
- for(std::size_t i = 0; i < m_real_num_node; ++i){
+ for(size_type i = 0; i < m_real_num_node; ++i){
prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *(node_t*)mem_address);
mem_address += m_real_node_size;
}
}
}
- void priv_alloc_block(std::size_t n, AlignOnlyFalse)
+ void priv_alloc_block(size_type n, AlignOnlyFalse)
{
- std::size_t real_block_size = m_real_block_alignment*m_num_subblocks - PayloadPerAllocation;
- std::size_t elements_per_subblock = (m_real_block_alignment - HdrOffsetSize)/m_real_node_size;
- std::size_t hdr_subblock_elements = (m_real_block_alignment - HdrSize - PayloadPerAllocation)/m_real_node_size;
+ size_type real_block_size = m_real_block_alignment*m_num_subblocks - PayloadPerAllocation;
+ size_type elements_per_subblock = (m_real_block_alignment - HdrOffsetSize)/m_real_node_size;
+ size_type hdr_subblock_elements = (m_real_block_alignment - HdrSize - PayloadPerAllocation)/m_real_node_size;
- for(std::size_t i = 0; i != n; ++i){
+ for(size_type i = 0; i != n; ++i){
//We allocate a new NodeBlock and put it the last
//element of the tree
char *mem_address = static_cast<char*>
@@ -585,13 +592,13 @@
BOOST_ASSERT(static_cast<void*>(&static_cast<hdr_offset_holder*>(c_info)->hdr_offset) ==
static_cast<void*>(c_info));
typename free_nodes_t::iterator prev_insert_pos = c_info->free_nodes.before_begin();
- for( std::size_t subblock = 0, maxsubblock = m_num_subblocks - 1
+ for( size_type subblock = 0, maxsubblock = m_num_subblocks - 1
; subblock < maxsubblock
; ++subblock, mem_address += m_real_block_alignment){
//Initialize header offset mark
- new(mem_address) hdr_offset_holder(std::size_t(hdr_addr - mem_address));
+ new(mem_address) hdr_offset_holder(size_type(hdr_addr - mem_address));
char *pNode = mem_address + HdrOffsetSize;
- for(std::size_t i = 0; i < elements_per_subblock; ++i){
+ for(size_type i = 0; i < elements_per_subblock; ++i){
prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *new (pNode) node_t);
pNode += m_real_node_size;
}
@@ -600,7 +607,7 @@
char *pNode = hdr_addr + HdrSize;
//We initialize all Nodes in Node Block to insert
//them in the free Node list
- for(std::size_t i = 0; i < hdr_subblock_elements; ++i){
+ for(size_type i = 0; i < hdr_subblock_elements; ++i){
prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *new (pNode) node_t);
pNode += m_real_node_size;
}
@@ -611,25 +618,25 @@
}
//!Allocates a block of nodes. Can throw std::bad_alloc
- void priv_alloc_block(std::size_t n)
+ void priv_alloc_block(size_type n)
{ return priv_alloc_block(n, IsAlignOnly()); }
private:
typedef typename boost::pointer_to_other
<void_pointer, segment_manager_base_type>::type segment_mngr_base_ptr_t;
- const std::size_t m_max_free_blocks;
- const std::size_t m_real_node_size;
+ const size_type m_max_free_blocks;
+ const size_type m_real_node_size;
//Round the size to a power of two value.
//This is the total memory size (including payload) that we want to
//allocate from the general-purpose allocator
- const std::size_t m_real_block_alignment;
- std::size_t m_num_subblocks;
+ const size_type m_real_block_alignment;
+ size_type m_num_subblocks;
//This is the real number of nodes per block
//const
- std::size_t m_real_num_node;
+ size_type m_real_num_node;
segment_mngr_base_ptr_t mp_segment_mngr_base; //Segment manager
block_multiset_t m_block_multiset; //Intrusive block list
- std::size_t m_totally_free_blocks; //Free blocks
+ size_type m_totally_free_blocks; //Free blocks
};
} //namespace containers_detail {
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -17,7 +17,7 @@
#include "config_begin.hpp"
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <iterator> //std::iterator_traits
#include <new> //placement new
#include <boost/assert.hpp>
@@ -50,21 +50,21 @@
{}
virtual void copy_all_to(Iterator p)
- { ::BOOST_CONTAINER_MOVE_NAMESPACE::copy_or_move(first_, last_, p); }
+ { ::boost::copy_or_move(first_, last_, p); }
virtual void uninitialized_copy_all_to(Iterator p)
- { ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first_, last_, p); }
+ { ::boost::uninitialized_copy_or_move(first_, last_, p); }
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
{
FwdIt mid = first_;
std::advance(mid, division_count);
if(first_n){
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first_, mid, pos);
+ ::boost::uninitialized_copy_or_move(first_, mid, pos);
first_ = mid;
}
else{
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(mid, last_, pos);
+ ::boost::uninitialized_copy_or_move(mid, last_, pos);
last_ = mid;
}
}
@@ -74,11 +74,11 @@
FwdIt mid = first_;
std::advance(mid, division_count);
if(first_n){
- ::BOOST_CONTAINER_MOVE_NAMESPACE::copy_or_move(first_, mid, pos);
+ ::boost::copy_or_move(first_, mid, pos);
first_ = mid;
}
else{
- ::BOOST_CONTAINER_MOVE_NAMESPACE::copy_or_move(mid, last_, pos);
+ ::boost::copy_or_move(mid, last_, pos);
last_ = mid;
}
}
@@ -164,7 +164,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_STORED_REF_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <typeinfo>
//#include <iostream> //For debugging purposes
@@ -205,7 +205,7 @@
void priv_copy_all_to(const index_tuple<IdxPack...>&, Iterator p)
{
if(!used_){
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T (::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
+ *p = boost::move(T (::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
used_ = true;
}
}
@@ -237,7 +237,7 @@
BOOST_ASSERT(division_count <=1);
if((first_n && division_count == 1) || (!first_n && division_count == 0)){
if(!used_){
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(T(::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
+ *p = boost::move(T(::boost::container::containers_detail::stored_ref<Args>::forward(get<IdxPack>(args_))...));
used_ = true;
}
}
@@ -274,7 +274,7 @@
{
if(!used_){
value_init<T>v;
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
+ *p = boost::move(v.m_t);
used_ = true;
}
}
@@ -304,7 +304,7 @@
if((first_n && division_count == 1) || (!first_n && division_count == 0)){
if(!used_){
value_init<T>v;
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v.m_t);
+ *p = boost::move(v.m_t);
used_ = true;
}
}
@@ -328,7 +328,7 @@
{ \
if(!used_){ \
T v(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_MEMBER_FORWARD, _)); \
- *p = BOOST_CONTAINER_MOVE_NAMESPACE::move(v); \
+ *p = boost::move(v); \
used_ = true; \
} \
} \
@@ -362,7 +362,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_CONTAINER_MOVE_NAMESPACE::move(v); \
+ *p = boost::move(v); \
used_ = true; \
} \
} \
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -77,8 +77,8 @@
::new((void*)dest)T();
}
-template<class T, class U, class E>
-inline void construct_in_place(T *dest, emplace_iterator<U, E> ei)
+template<class T, class U, class E, class D>
+inline void construct_in_place(T *dest, emplace_iterator<U, E, D> ei)
{
ei.construct_in_place(dest);
}
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -12,19 +12,6 @@
#include <boost/config.hpp>
#define BOOST_CONTAINER_IN_INTERPROCESS
-#define BOOST_MOVE_IN_INTERPROCESS
-
-#ifdef BOOST_MOVE_IN_INTERPROCESS
-
-#define INCLUDE_BOOST_CONTAINER_MOVE_HPP <boost/interprocess/detail/move.hpp>
-#define BOOST_CONTAINER_MOVE_NAMESPACE boost::interprocess
-
-#else
-
-#define INCLUDE_BOOST_CONTAINER_MOVE_HPP <boost/move/move.hpp>
-#define BOOST_CONTAINER_MOVE_NAMESPACE boost
-
-#endif
#ifdef BOOST_CONTAINER_IN_INTERPROCESS
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -89,7 +89,7 @@
{
if(!m_p) return;
value_type *raw_ptr = containers_detail::get_pointer(m_p);
- for(std::size_t i = 0; i < m_n; ++i, ++raw_ptr)
+ for(size_type i = 0; i < m_n; ++i, ++raw_ptr)
raw_ptr->~value_type();
}
};
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -42,7 +42,7 @@
#include <utility>
#include <boost/type_traits/has_trivial_destructor.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
@@ -108,7 +108,7 @@
: public value_compare
{
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(Data)
+ BOOST_COPYABLE_AND_MOVABLE(Data)
public:
Data(const Data &d)
: value_compare(d), m_vect(d.m_vect)
@@ -125,17 +125,17 @@
const allocator_t &alloc)
: value_compare(comp), m_vect(alloc){}
- Data& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(Data) d)
+ Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
{
this->value_compare::operator=(d);
m_vect = d.m_vect;
return *this;
}
- Data& operator=(BOOST_MOVE_MACRO_RV_REF(Data) d)
+ Data& operator=(BOOST_RV_REF(Data) d)
{
- this->value_compare::operator=(BOOST_CONTAINER_MOVE_NAMESPACE::move(static_cast<value_compare &>(d)));
- m_vect = BOOST_CONTAINER_MOVE_NAMESPACE::move(d.m_vect);
+ this->value_compare::operator=(boost::move(static_cast<value_compare &>(d)));
+ m_vect = boost::move(d.m_vect);
return *this;
}
@@ -143,7 +143,7 @@
};
Data m_data;
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_tree)
+ BOOST_COPYABLE_AND_MOVABLE(flat_tree)
public:
@@ -174,8 +174,8 @@
: m_data(x.m_data, x.m_data.m_vect)
{ }
- flat_tree(BOOST_MOVE_MACRO_RV_REF(flat_tree) x)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_data))
+ flat_tree(BOOST_RV_REF(flat_tree) x)
+ : m_data(boost::move(x.m_data))
{ }
template <class InputIterator>
@@ -188,11 +188,11 @@
~flat_tree()
{ }
- flat_tree& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_tree) x)
+ flat_tree& operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
{ m_data = x.m_data; return *this; }
- flat_tree& operator=(BOOST_MOVE_MACRO_RV_REF(flat_tree) mx)
- { m_data = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_data); return *this; }
+ flat_tree& operator=(BOOST_RV_REF(flat_tree) mx)
+ { m_data = boost::move(mx.m_data); return *this; }
public:
// accessors:
@@ -275,12 +275,12 @@
return ret;
}
- std::pair<iterator,bool> insert_unique(BOOST_MOVE_MACRO_RV_REF(value_type) val)
+ std::pair<iterator,bool> insert_unique(BOOST_RV_REF(value_type) val)
{
insert_commit_data data;
std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
}
return ret;
}
@@ -293,10 +293,10 @@
return i;
}
- iterator insert_equal(BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_equal(BOOST_RV_REF(value_type) mval)
{
iterator i = this->upper_bound(KeyOfValue()(mval));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ i = this->m_data.m_vect.insert(i, boost::move(mval));
return i;
}
@@ -310,12 +310,12 @@
return ret.first;
}
- iterator insert_unique(const_iterator pos, BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_unique(const_iterator pos, BOOST_RV_REF(value_type) mval)
{
insert_commit_data data;
std::pair<iterator,bool> ret = priv_insert_unique_prepare(pos, mval, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ ret.first = priv_insert_commit(data, boost::move(mval));
}
return ret.first;
}
@@ -327,11 +327,11 @@
return priv_insert_commit(data, val);
}
- iterator insert_equal(const_iterator pos, BOOST_MOVE_MACRO_RV_REF(value_type) mval)
+ iterator insert_equal(const_iterator pos, BOOST_RV_REF(value_type) mval)
{
insert_commit_data data;
priv_insert_equal_prepare(pos, mval, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(mval));
+ return priv_insert_commit(data, boost::move(mval));
}
template <class InIt>
@@ -354,12 +354,12 @@
template <class... Args>
iterator emplace_unique(Args&&... args)
{
- value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type && val = value_type(boost::forward<Args>(args)...);
insert_commit_data data;
std::pair<iterator,bool> ret =
priv_insert_unique_prepare(val, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
}
return ret.first;
}
@@ -367,11 +367,11 @@
template <class... Args>
iterator emplace_hint_unique(const_iterator hint, Args&&... args)
{
- value_type && val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type && val = value_type(boost::forward<Args>(args)...);
insert_commit_data data;
std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
}
return ret.first;
}
@@ -379,19 +379,19 @@
template <class... Args>
iterator emplace_equal(Args&&... args)
{
- value_type &&val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type &&val = value_type(boost::forward<Args>(args)...);
iterator i = this->upper_bound(KeyOfValue()(val));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ i = this->m_data.m_vect.insert(i, boost::move(val));
return i;
}
template <class... Args>
iterator emplace_hint_equal(const_iterator hint, Args&&... args)
{
- value_type &&val = value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ value_type &&val = value_type(boost::forward<Args>(args)...);
insert_commit_data data;
priv_insert_equal_prepare(hint, val, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ return priv_insert_commit(data, boost::move(val));
}
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -404,7 +404,7 @@
std::pair<iterator,bool> ret =
priv_insert_unique_prepare(val, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
}
return ret.first;
}
@@ -416,7 +416,7 @@
insert_commit_data data;
std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);
if(ret.second){
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ ret.first = priv_insert_commit(data, boost::move(val));
}
return ret.first;
}
@@ -426,7 +426,7 @@
containers_detail::value_init<value_type> vval;
value_type &val = vval.m_t;
iterator i = this->upper_bound(KeyOfValue()(val));
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ i = this->m_data.m_vect.insert(i, boost::move(val));
return i;
}
@@ -436,7 +436,7 @@
value_type &val = vval.m_t;
insert_commit_data data;
priv_insert_equal_prepare(hint, val, data);
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ return priv_insert_commit(data, boost::move(val));
}
#define BOOST_PP_LOCAL_MACRO(n) \
@@ -447,7 +447,7 @@
insert_commit_data data; \
std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data); \
if(ret.second){ \
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val)); \
+ ret.first = priv_insert_commit(data, boost::move(val)); \
} \
return ret.first; \
} \
@@ -460,7 +460,7 @@
insert_commit_data data; \
std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data); \
if(ret.second){ \
- ret.first = priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val)); \
+ ret.first = priv_insert_commit(data, boost::move(val)); \
} \
return ret.first; \
} \
@@ -470,7 +470,7 @@
{ \
value_type val(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
iterator i = this->upper_bound(KeyOfValue()(val)); \
- i = this->m_data.m_vect.insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val)); \
+ i = this->m_data.m_vect.insert(i, boost::move(val)); \
return i; \
} \
\
@@ -481,7 +481,7 @@
value_type val(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
insert_commit_data data; \
priv_insert_equal_prepare(hint, val, data); \
- return priv_insert_commit(data, BOOST_CONTAINER_MOVE_NAMESPACE::move(val)); \
+ return priv_insert_commit(data, boost::move(val)); \
} \
//!
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_CONTAINERS_MAX_CONSTRUCTOR_PARAMETERS)
@@ -677,11 +677,11 @@
template<class Convertible>
iterator priv_insert_commit
- (insert_commit_data &commit_data, BOOST_MOVE_MACRO_FWD_REF(Convertible) convertible)
+ (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
{
return this->m_data.m_vect.insert
( commit_data.position
- , BOOST_CONTAINER_MOVE_NAMESPACE::forward<Convertible>(convertible));
+ , boost::forward<Convertible>(convertible));
}
template <class RanIt>
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -20,7 +20,7 @@
#include "config_begin.hpp"
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
@@ -368,14 +368,15 @@
{ return m_num - other.m_num; }
};
-template <class T, class E>
+template <class T, class E, class Difference /*= std::ptrdiff_t*/>
class emplace_iterator
: public std::iterator
- <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
+ <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
typedef emplace_iterator this_type;
public:
+ typedef Difference difference_type;
explicit emplace_iterator(E&e)
: m_num(1), m_pe(&e){}
@@ -420,33 +421,33 @@
friend bool operator>= (const this_type& i, const this_type& i2)
{ return !(i < i2); }
- friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
+ friend difference_type operator- (const this_type& i, const this_type& i2)
{ return i2.distance_to(i); }
//Arithmetic
- this_type& operator+=(std::ptrdiff_t off)
+ this_type& operator+=(difference_type off)
{ this->advance(off); return *this; }
- this_type operator+(std::ptrdiff_t off) const
+ this_type operator+(difference_type off) const
{
this_type other(*this);
other.advance(off);
return other;
}
- friend this_type operator+(std::ptrdiff_t off, const this_type& right)
+ friend this_type operator+(difference_type off, const this_type& right)
{ return right + off; }
- this_type& operator-=(std::ptrdiff_t off)
+ this_type& operator-=(difference_type off)
{ this->advance(-off); return *this; }
- this_type operator-(std::ptrdiff_t off) const
+ this_type operator-(difference_type off) const
{ return *this + (-off); }
const T& operator*() const
{ return dereference(); }
- const T& operator[](std::ptrdiff_t) const
+ const T& operator[](difference_type) const
{ return dereference(); }
const T* operator->() const
@@ -456,7 +457,7 @@
{ (*m_pe)(ptr); }
private:
- std::ptrdiff_t m_num;
+ difference_type m_num;
E * m_pe;
void increment()
@@ -477,11 +478,11 @@
return dummy;
}
- void advance(std::ptrdiff_t n)
+ void advance(difference_type n)
{ m_num -= n; }
- std::ptrdiff_t distance_to(const this_type &other)const
- { return m_num - other.m_num; }
+ difference_type distance_to(const this_type &other)const
+ { return difference_type(m_num - other.m_num); }
};
#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -18,7 +18,8 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP
#include <boost/intrusive/slist.hpp>
#include <boost/pointer_to_other.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/move/move.hpp>
namespace boost {
namespace container {
@@ -32,34 +33,39 @@
,bi::link_mode<bi::normal_link>
> node;
+ typedef typename boost::pointer_to_other<VoidPointer, char>::type char_ptr;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+
typedef bi::slist< node
, bi::linear<true>
, bi::cache_last<true>
+ , bi::size_type<typename boost::make_unsigned<difference_type>::type>
> slist_impl_t;
slist_impl_t slist_impl_;
static node & to_node(VoidPointer p)
{ return *static_cast<node*>(static_cast<void*>(containers_detail::get_pointer(p))); }
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
public:
typedef VoidPointer void_pointer;
typedef typename slist_impl_t::iterator iterator;
+ typedef typename slist_impl_t::size_type size_type;
basic_multiallocation_chain()
: slist_impl_()
{}
- basic_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
+ basic_multiallocation_chain(BOOST_RV_REF(basic_multiallocation_chain) other)
: slist_impl_()
{ slist_impl_.swap(other.slist_impl_); }
- basic_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
+ basic_multiallocation_chain& operator=(BOOST_RV_REF(basic_multiallocation_chain) other)
{
- basic_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
+ basic_multiallocation_chain tmp(boost::move(other));
this->swap(tmp);
return *this;
}
@@ -67,7 +73,7 @@
bool empty() const
{ return slist_impl_.empty(); }
- std::size_t size() const
+ size_type size() const
{ return slist_impl_.size(); }
iterator before_begin()
@@ -103,7 +109,7 @@
void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
{ slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end); }
- void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
+ void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
{ slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n); }
void splice_after(iterator after_this, basic_multiallocation_chain &x)
@@ -112,7 +118,7 @@
void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
{ slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end)); }
- void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
+ void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
{ slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end), n); }
void swap(basic_multiallocation_chain &x)
@@ -144,7 +150,7 @@
class transform_multiallocation_chain
{
private:
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)
MultiallocationChain holder_;
typedef typename MultiallocationChain::void_pointer void_pointer;
@@ -160,22 +166,23 @@
typedef transform_iterator
< typename MultiallocationChain::iterator
, containers_detail::cast_functor <T> > iterator;
+ typedef typename MultiallocationChain::size_type size_type;
transform_multiallocation_chain()
: holder_()
{}
- transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
+ transform_multiallocation_chain(BOOST_RV_REF(transform_multiallocation_chain) other)
: holder_()
{ this->swap(other); }
- transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(MultiallocationChain) other)
- : holder_(BOOST_CONTAINER_MOVE_NAMESPACE::move(other))
+ transform_multiallocation_chain(BOOST_RV_REF(MultiallocationChain) other)
+ : holder_(boost::move(other))
{}
- transform_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
+ transform_multiallocation_chain& operator=(BOOST_RV_REF(transform_multiallocation_chain) other)
{
- transform_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
+ transform_multiallocation_chain tmp(boost::move(other));
this->swap(tmp);
return *this;
}
@@ -186,10 +193,10 @@
void swap(transform_multiallocation_chain &other_chain)
{ holder_.swap(other_chain.holder_); }
- void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
+ void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
{ holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n); }
- void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
+ void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
{ holder_.incorporate_after(after_this.base(), begin, before_end, n); }
void pop_front()
@@ -213,7 +220,7 @@
iterator last()
{ return iterator(holder_.last()); }
- std::size_t size() const
+ size_type size() const
{ return holder_.size(); }
void clear()
@@ -230,7 +237,7 @@
MultiallocationChain extract_multiallocation_chain()
{
- return MultiallocationChain(BOOST_CONTAINER_MOVE_NAMESPACE::move(holder_));
+ return MultiallocationChain(boost::move(holder_));
}
};
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -21,7 +21,7 @@
#include <utility>
#include <functional>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/intrusive/options.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
@@ -60,7 +60,7 @@
void priv_deallocate(allocator_v2)
{ m_alloc.deallocate_one(m_ptr); }
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
public:
@@ -74,7 +74,7 @@
~scoped_deallocator()
{ if (m_ptr)priv_deallocate(alloc_version()); }
- scoped_deallocator(BOOST_MOVE_MACRO_RV_REF(scoped_deallocator) o)
+ scoped_deallocator(BOOST_RV_REF(scoped_deallocator) o)
: m_ptr(o.m_ptr), m_alloc(o.m_alloc)
{ o.release(); }
@@ -128,7 +128,7 @@
~allocator_multialloc_chain_node_deallocator()
{
if(!c_.empty())
- a_.deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(c_));
+ a_.deallocate_individual(boost::move(c_));
}
};
@@ -177,7 +177,7 @@
typedef allocator_destroyer<NodeAlloc> Destroyer;
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(node_alloc_holder)
+ BOOST_COPYABLE_AND_MOVABLE(node_alloc_holder)
public:
@@ -189,14 +189,14 @@
: members_(other.node_alloc())
{}
- node_alloc_holder(BOOST_MOVE_MACRO_RV_REF(node_alloc_holder) other)
- : members_(BOOST_CONTAINER_MOVE_NAMESPACE::move(other.node_alloc()))
+ node_alloc_holder(BOOST_RV_REF(node_alloc_holder) other)
+ : members_(boost::move(other.node_alloc()))
{ this->swap(other); }
- node_alloc_holder & operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(node_alloc_holder) other)
+ node_alloc_holder & operator=(BOOST_COPY_ASSIGN_REF(node_alloc_holder) other)
{ members_.assign(other.node_alloc()); }
- node_alloc_holder & operator=(BOOST_MOVE_MACRO_RV_REF(node_alloc_holder) other)
+ node_alloc_holder & operator=(BOOST_RV_REF(node_alloc_holder) other)
{ members_.assign(other.node_alloc()); }
template<class Pred>
@@ -205,7 +205,7 @@
{}
template<class Pred>
- node_alloc_holder(BOOST_MOVE_MACRO_RV_REF(ValAlloc) a, const Pred &c)
+ node_alloc_holder(BOOST_RV_REF(ValAlloc) a, const Pred &c)
: members_(a, typename ICont::value_compare(c))
{}
@@ -240,7 +240,7 @@
template<class Convertible1, class Convertible2>
static void construct(const NodePtr &ptr,
- BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, Convertible1, Convertible2) value)
+ BOOST_RV_REF_2_TEMPL_ARGS(std::pair, Convertible1, Convertible2) value)
{
typedef typename Node::hook_type hook_type;
typedef typename Node::value_type::first_type first_type;
@@ -251,9 +251,9 @@
new(static_cast<hook_type*>(nodeptr))hook_type();
//Now construct pair members_holder
value_type *valueptr = &nodeptr->get_data();
- new((void*)&valueptr->first) first_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(value.first));
+ new((void*)&valueptr->first) first_type(boost::move(value.first));
BOOST_TRY{
- new((void*)&valueptr->second) second_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(value.second));
+ new((void*)&valueptr->second) second_type(boost::move(value.second));
}
BOOST_CATCH(...){
valueptr->first.~first_type();
@@ -275,14 +275,14 @@
template<class ...Args>
static void construct(const NodePtr &ptr, Args &&...args)
- { new((void*)containers_detail::get_pointer(ptr)) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { new((void*)containers_detail::get_pointer(ptr)) Node(boost::forward<Args>(args)...); }
template<class ...Args>
NodePtr create_node(Args &&...args)
{
NodePtr p = this->allocate_one();
Deallocator node_deallocator(p, this->node_alloc());
- self_t::construct(p, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ self_t::construct(p, boost::forward<Args>(args)...);
node_deallocator.release();
return (p);
}
@@ -383,7 +383,7 @@
if(constructed){
this->destroy(p);
}
- this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(mem));
+ this->node_alloc().deallocate_individual(boost::move(mem));
BOOST_RETHROW
}
BOOST_CATCH_END
@@ -399,9 +399,9 @@
typename NodeAlloc::multiallocation_chain chain;
allocator_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
this->icont().clear_and_dispose(builder);
- BOOST_STATIC_ASSERT((::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<typename NodeAlloc::multiallocation_chain>::value == true));
+ //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
if(!chain.empty())
- this->node_alloc().deallocate_individual(BOOST_CONTAINER_MOVE_NAMESPACE::move(chain));
+ this->node_alloc().deallocate_individual(boost::move(chain));
}
icont_iterator erase_range(icont_iterator first, icont_iterator last, allocator_v1)
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -49,6 +49,7 @@
typedef typename node_slist<void_pointer>::node_t node_t;
typedef typename node_slist<void_pointer>::node_slist_t free_nodes_t;
typedef typename SegmentManagerBase::multiallocation_chain multiallocation_chain;
+ typedef typename SegmentManagerBase::size_type size_type;
private:
typedef typename bi::make_slist
@@ -61,9 +62,9 @@
typedef SegmentManagerBase segment_manager_base_type;
//!Constructor from a segment manager. Never throws
- private_node_pool_impl(segment_manager_base_type *segment_mngr_base, std::size_t node_size, std::size_t nodes_per_block)
+ private_node_pool_impl(segment_manager_base_type *segment_mngr_base, size_type node_size, size_type nodes_per_block)
: m_nodes_per_block(nodes_per_block)
- , m_real_node_size(lcm(node_size, std::size_t(alignment_of<node_t>::value)))
+ , m_real_node_size(lcm(node_size, size_type(alignment_of<node_t>::value)))
//General purpose allocator
, mp_segment_mngr_base(segment_mngr_base)
, m_blocklist()
@@ -76,7 +77,7 @@
~private_node_pool_impl()
{ this->purge_blocks(); }
- std::size_t get_real_num_node() const
+ size_type get_real_num_node() const
{ return m_nodes_per_block; }
//!Returns the segment manager. Never throws
@@ -91,10 +92,10 @@
{ priv_dealloc_node(ptr); }
//!Allocates a singly linked list of n nodes ending in null pointer.
- multiallocation_chain allocate_nodes(const std::size_t n)
+ multiallocation_chain allocate_nodes(const size_type n)
{
//Preallocate all needed blocks to fulfill the request
- std::size_t cur_nodes = m_freelist.size();
+ size_type cur_nodes = m_freelist.size();
if(cur_nodes < n){
priv_alloc_block(((n - cur_nodes) - 1)/m_nodes_per_block + 1);
}
@@ -102,7 +103,7 @@
//We just iterate the needed nodes to get the last we'll erase
typedef typename free_nodes_t::iterator free_iterator;
free_iterator before_last_new_it = m_freelist.before_begin();
- for(std::size_t j = 0; j != n; ++j){
+ for(size_type j = 0; j != n; ++j){
++before_last_new_it;
}
@@ -120,7 +121,7 @@
multiallocation_chain chain;
chain.incorporate_after(chain.before_begin(), &*first_node, &*last_node, n);
m_allocated += n;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(chain);
+ return boost::move(chain);
}
void deallocate_nodes(multiallocation_chain chain)
@@ -145,8 +146,8 @@
nodelist_iterator backup_list_last = backup_list.before_begin();
//Execute the algorithm and get an iterator to the last value
- std::size_t blocksize = get_rounded_size
- (m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ size_type blocksize = get_rounded_size
+ (m_real_node_size*m_nodes_per_block, (size_type) alignment_of<node_t>::value);
while(it != itend){
//Collect all the nodes from the block pointed by it
@@ -196,7 +197,7 @@
, backup_list.size());
}
- std::size_t num_free_nodes()
+ size_type num_free_nodes()
{ return m_freelist.size(); }
//!Deallocates all used memory. Precondition: all nodes allocated from this pool should
@@ -205,8 +206,8 @@
{
//check for memory leaks
BOOST_ASSERT(m_allocated==0);
- std::size_t blocksize = get_rounded_size
- (m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ size_type blocksize = get_rounded_size
+ (m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
typename blockslist_t::iterator
it(m_blocklist.begin()), itend(m_blocklist.end()), aux;
@@ -294,15 +295,15 @@
}
//!Allocates several blocks of nodes. Can throw
- void priv_alloc_block(std::size_t num_blocks = 1)
+ void priv_alloc_block(size_type num_blocks = 1)
{
if(!num_blocks)
return;
- std::size_t blocksize =
- get_rounded_size(m_real_node_size*m_nodes_per_block, alignment_of<node_t>::value);
+ size_type blocksize =
+ get_rounded_size(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
try{
- for(std::size_t i = 0; i != num_blocks; ++i){
+ for(size_type i = 0; i != num_blocks; ++i){
//We allocate a new NodeBlock and put it as first
//element in the free Node list
char *pNode = reinterpret_cast<char*>
@@ -312,7 +313,7 @@
//We initialize all Nodes in Node Block to insert
//them in the free Node list
- for(std::size_t i = 0; i < m_nodes_per_block; ++i, pNode += m_real_node_size){
+ for(size_type i = 0; i < m_nodes_per_block; ++i, pNode += m_real_node_size){
m_freelist.push_front(*new (pNode) node_t);
}
}
@@ -333,13 +334,13 @@
private:
//!Returns a reference to the block hook placed in the end of the block
- static node_t & get_block_hook (void *block, std::size_t blocksize)
+ static node_t & get_block_hook (void *block, size_type blocksize)
{
return *reinterpret_cast<node_t*>(reinterpret_cast<char*>(block) + blocksize);
}
//!Returns the starting address of the block reference to the block hook placed in the end of the block
- void *get_block_from_hook (node_t *hook, std::size_t blocksize)
+ void *get_block_from_hook (node_t *hook, size_type blocksize)
{
return (reinterpret_cast<char*>(hook) - blocksize);
}
@@ -348,12 +349,12 @@
typedef typename boost::pointer_to_other
<void_pointer, segment_manager_base_type>::type segment_mngr_base_ptr_t;
- const std::size_t m_nodes_per_block;
- const std::size_t m_real_node_size;
+ const size_type m_nodes_per_block;
+ const size_type m_real_node_size;
segment_mngr_base_ptr_t mp_segment_mngr_base; //Segment manager
blockslist_t m_blocklist; //Intrusive container of blocks
free_nodes_t m_freelist; //Intrusive container of free nods
- std::size_t m_allocated; //Used nodes for debugging
+ size_type m_allocated; //Used nodes for debugging
};
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -25,7 +25,8 @@
#include <utility> //std::pair
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/type_traits/is_class.hpp>
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
@@ -39,7 +40,7 @@
struct pair
{
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(pair)
+ BOOST_COPYABLE_AND_MOVABLE(pair)
public:
typedef T1 first_type;
@@ -61,8 +62,8 @@
{}
template <class D, class S>
- pair(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+ pair(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ : first(boost::move(p.first)), second(boost::move(p.second))
{}
pair()
@@ -72,28 +73,28 @@
pair(const pair<T1, T2>& x)
: first(x.first), second(x.second)
{}
-
+/*
//To resolve ambiguity with the variadic constructor of 1 argument
//and the copy constructor
pair(pair<T1, T2>& x)
: first(x.first), second(x.second)
{}
-
- pair(BOOST_MOVE_MACRO_RV_REF(pair) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+*/
+ pair(BOOST_RV_REF(pair) p)
+ : first(boost::move(p.first)), second(boost::move(p.second))
{}
template <class D, class S>
- pair(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first)), second(BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second))
+ pair(BOOST_RV_REF_2_TEMPL_ARGS(pair, D, S) p)
+ : first(boost::move(p.first)), second(boost::move(p.second))
{}
#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
template<class U, class ...Args>
pair(U &&u, Args &&... args)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward<U>(u))
- , second(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : first(boost::forward<U>(u))
+ , second(boost::forward<Args>(args)...)
{}
#else
@@ -102,17 +103,17 @@
pair( BOOST_CONTAINERS_PARAM(U, u)
#ifdef BOOST_NO_RVALUE_REFERENCES
, typename containers_detail::disable_if
- < containers_detail::is_same<U, ::BOOST_CONTAINER_MOVE_NAMESPACE::rv<pair> > >::type* = 0
+ < containers_detail::is_same<U, ::boost::rv<pair> > >::type* = 0
#endif
)
- : first(BOOST_CONTAINER_MOVE_NAMESPACE::forward<U>(const_cast<U&>(u)))
+ : first(boost::forward<U>(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_CONTAINER_MOVE_NAMESPACE::forward<U>(const_cast<U&>(u))) \
+ : first(boost::forward<U>(const_cast<U&>(u))) \
, second(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)) \
{} \
//!
@@ -120,32 +121,32 @@
#include BOOST_PP_LOCAL_ITERATE()
#endif
- pair& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(pair) p)
+ pair& operator=(BOOST_COPY_ASSIGN_REF(pair) p)
{
first = p.first;
second = p.second;
return *this;
}
- pair& operator=(BOOST_MOVE_MACRO_RV_REF(pair) p)
+ pair& operator=(BOOST_RV_REF(pair) p)
{
- first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
- second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
+ first = boost::move(p.first);
+ second = boost::move(p.second);
return *this;
}
- pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
+ pair& operator=(BOOST_RV_REF_2_TEMPL_ARGS(std::pair, T1, T2) p)
{
- first = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.first);
- second = BOOST_CONTAINER_MOVE_NAMESPACE::move(p.second);
+ first = boost::move(p.first);
+ second = boost::move(p.second);
return *this;
}
template <class D, class S>
- pair& operator=(BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(std::pair, D, S) p)
+ pair& operator=(BOOST_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);
+ first = boost::move(p.first);
+ second = boost::move(p.second);
return *this;
}
@@ -205,6 +206,23 @@
static const bool value = false;
};
+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+template <class T1, class T2>
+struct is_class< ::boost::container::containers_detail::pair<T1, T2> >
+ : public ::boost::true_type
+{};
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+
+template<class T1, class T2>
+struct has_move_emulation_enabled< ::boost::container::containers_detail::pair<T1, T2> >
+ : ::boost::true_type
+{};
+
+#endif
+
+
} //namespace boost {
#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -66,7 +66,7 @@
#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
#define BOOST_CONTAINERS_AUX_PARAM_INIT(z, n, data) \
- BOOST_PP_CAT(m_p, n) (BOOST_CONTAINER_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) )) \
+ BOOST_PP_CAT(m_p, n) (boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) )) \
//!
#else
@@ -111,7 +111,7 @@
#endif
#define BOOST_CONTAINERS_PP_PARAM_FORWARD(z, n, data) \
-BOOST_CONTAINER_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
+boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
//!
#if !defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
@@ -123,7 +123,7 @@
#else
#define BOOST_CONTAINERS_PP_MEMBER_FORWARD(z, n, data) \
-BOOST_CONTAINER_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(m_p, n) ) \
+boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(m_p, n) ) \
//!
#endif //!defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
Modified: trunk/boost/interprocess/containers/container/detail/stored_ref.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/detail/stored_ref.hpp (original)
+++ trunk/boost/interprocess/containers/container/detail/stored_ref.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -28,7 +28,7 @@
#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
{ return t; }
#else
- { return BOOST_CONTAINER_MOVE_NAMESPACE::move(t); }
+ { return boost::move(t); }
#endif
};
@@ -50,7 +50,7 @@
#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
{ return t; }
#else
- { return BOOST_CONTAINER_MOVE_NAMESPACE::move(t); }
+ { return boost::move(t); }
#endif
};
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -15,7 +15,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/detail/no_exceptions_support.hpp>
@@ -122,7 +122,7 @@
template<class ...Args>
rbtree_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
{}
#endif//#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -164,8 +164,8 @@
public:
template<class Convertible>
- static void construct(node_type *ptr, BOOST_MOVE_MACRO_FWD_REF(Convertible) convertible)
- { new(ptr) node_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Convertible>(convertible)); }
+ static void construct(node_type *ptr, BOOST_FWD_REF(Convertible) convertible)
+ { new(ptr) node_type(boost::forward<Convertible>(convertible)); }
};
}//namespace containers_detail {
@@ -267,7 +267,7 @@
AllocHolder &m_holder;
Icont &m_icont;
};
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(rbtree)
+ BOOST_COPYABLE_AND_MOVABLE(rbtree)
public:
@@ -437,14 +437,14 @@
(x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
}
- rbtree(BOOST_MOVE_MACRO_RV_REF(rbtree) x)
+ rbtree(BOOST_RV_REF(rbtree) x)
: AllocHolder(x, x.key_comp())
{ this->swap(x); }
~rbtree()
{} //AllocHolder clears the tree
- rbtree& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(rbtree) x)
+ rbtree& operator=(BOOST_COPY_ASSIGN_REF(rbtree) x)
{
if (this != &x) {
//Transfer all the nodes to a temporary tree
@@ -469,7 +469,7 @@
return *this;
}
- rbtree& operator=(BOOST_MOVE_MACRO_RV_REF(rbtree) mx)
+ rbtree& operator=(BOOST_RV_REF(rbtree) mx)
{ this->clear(); this->swap(mx); return *this; }
public:
@@ -589,9 +589,9 @@
template<class MovableConvertible>
iterator insert_unique_commit
- (BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv, insert_commit_data &data)
+ (BOOST_FWD_REF(MovableConvertible) mv, insert_commit_data &data)
{
- NodePtr tmp = AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv));
+ NodePtr tmp = AllocHolder::create_node(boost::forward<MovableConvertible>(mv));
iiterator it(this->icont().insert_unique_commit(*tmp, data));
return iterator(it);
}
@@ -608,7 +608,7 @@
}
template<class MovableConvertible>
- std::pair<iterator,bool> insert_unique(BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ std::pair<iterator,bool> insert_unique(BOOST_FWD_REF(MovableConvertible) mv)
{
insert_commit_data data;
std::pair<iterator,bool> ret =
@@ -616,7 +616,7 @@
if(!ret.second)
return ret;
return std::pair<iterator,bool>
- (this->insert_unique_commit(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv), data), true);
+ (this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data), true);
}
private:
@@ -652,23 +652,23 @@
template <class... Args>
iterator emplace_unique(Args&&... args)
- { return this->emplace_unique_impl(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return this->emplace_unique_impl(AllocHolder::create_node(boost::forward<Args>(args)...)); }
template <class... Args>
iterator emplace_hint_unique(const_iterator hint, Args&&... args)
- { return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(boost::forward<Args>(args)...)); }
template <class... Args>
iterator emplace_equal(Args&&... args)
{
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
return iterator(this->icont().insert_equal(this->icont().end(), *p));
}
template <class... Args>
iterator emplace_hint_equal(const_iterator hint, Args&&... args)
{
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
return iterator(this->icont().insert_equal(hint.get(), *p));
}
@@ -737,14 +737,14 @@
}
template<class MovableConvertible>
- iterator insert_unique(const_iterator hint, BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_unique(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
{
insert_commit_data data;
std::pair<iterator,bool> ret =
this->insert_unique_check(hint, KeyOfValue()(mv), data);
if(!ret.second)
return ret.first;
- return this->insert_unique_commit(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv), data);
+ return this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data);
}
template <class InputIterator>
@@ -770,9 +770,9 @@
}
template<class MovableConvertible>
- iterator insert_equal(BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_equal(BOOST_FWD_REF(MovableConvertible) mv)
{
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv)));
+ NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
return iterator(this->icont().insert_equal(this->icont().end(), *p));
}
@@ -783,9 +783,9 @@
}
template<class MovableConvertible>
- iterator insert_equal(const_iterator hint, BOOST_MOVE_MACRO_FWD_REF(MovableConvertible) mv)
+ iterator insert_equal(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
{
- NodePtr p(AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<MovableConvertible>(mv)));
+ NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
return iterator(this->icont().insert_equal(hint.get(), *p));
}
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -17,7 +17,8 @@
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_member_pointer.hpp>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/type_traits/is_class.hpp>
+#include <boost/move/move.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <algorithm>
@@ -87,7 +88,8 @@
}
//Rounds "orig_size" by excess to round_to bytes
-inline std::size_t get_rounded_size(std::size_t orig_size, std::size_t round_to)
+template<class SizeType>
+inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
{
return ((orig_size-1)/round_to+1)*round_to;
}
@@ -131,10 +133,10 @@
template<class T>
struct move_const_ref_type
: if_c
- < ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value ||
- ::boost::is_member_pointer<T>::value || ::boost::is_enum<T>::value
+// < ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value || ::boost::is_enum<T>::value
+ < !::boost::is_class<T>::value
,const T &
- ,BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(T)
+ ,BOOST_CATCH_CONST_RLVALUE(T)
>
{};
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
@@ -14,7 +14,7 @@
#include "config_begin.hpp"
#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)\
- && !defined(BOOST_MOVE_MACRO_DISABLE_VARIADIC_TMPL)
+ && !defined(BOOST_INTERPROCESS_DISABLE_VARIADIC_TMPL)
#define BOOST_CONTAINERS_PERFECT_FORWARDING
#endif
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -26,7 +26,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
#include <boost/type_traits/has_trivial_destructor.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -76,7 +76,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_map)
+ BOOST_COPYABLE_AND_MOVABLE(flat_map)
//This is the tree that we should store if pair was movable
typedef containers_detail::flat_tree<Key,
std::pair<Key, T>,
@@ -192,14 +192,14 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- flat_map(BOOST_MOVE_MACRO_RV_REF(flat_map) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_map(BOOST_RV_REF(flat_map) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- flat_map<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_map) x)
+ flat_map<Key,T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
{ m_flat_tree = x.m_flat_tree; return *this; }
//! <b>Effects</b>: Move constructs a flat_map.
@@ -208,8 +208,8 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- flat_map<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_map) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_map<Key,T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_map) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -385,13 +385,13 @@
//! Returns: A reference to the mapped_type corresponding to x in *this.
//!
//! Complexity: Logarithmic.
- T &operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk)
+ T &operator[](BOOST_RV_REF(key_type) mk)
{
key_type &k = mk;
iterator i = lower_bound(k);
// i->first is greater than or equivalent to k.
if (i == end() || key_comp()(k, (*i).first))
- i = insert(i, value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T())));
+ i = insert(i, value_type(boost::move(k), boost::move(T())));
return (*i).second;
}
@@ -454,9 +454,9 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
{ return force<std::pair<iterator,bool> >(
- m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(force<impl_value_type>(x)))); }
+ m_flat_tree.insert_unique(boost::move(force<impl_value_type>(x)))); }
//! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
//! only if there is no element in the container with key equivalent to the key of x.
@@ -469,10 +469,10 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ std::pair<iterator,bool> insert(BOOST_RV_REF(impl_value_type) x)
{
return force<std::pair<iterator,bool> >
- (m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ (m_flat_tree.insert_unique(boost::move(x)));
}
//! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
@@ -499,9 +499,9 @@
//! right before p) plus insertion linear to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
{ return force_copy<iterator>(
- m_flat_tree.insert_unique(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(force<impl_value_type>(x)))); }
+ m_flat_tree.insert_unique(force<impl_const_iterator>(position), boost::move(force<impl_value_type>(x)))); }
//! <b>Effects</b>: Inserts an element move constructed from x in the container.
//! p is a hint pointing to where the insert should start to search.
@@ -512,10 +512,10 @@
//! right before p) plus insertion linear to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
{
return force_copy<iterator>(
- m_flat_tree.insert_unique(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ m_flat_tree.insert_unique(force<impl_const_iterator>(position), boost::move(x)));
}
//! <b>Requires</b>: i, j are not iterators into *this.
@@ -547,7 +547,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace(Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... in the container if and only if there is
@@ -563,7 +563,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), boost::forward<Args>(args)...)); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -818,7 +818,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_multimap)
+ BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
typedef containers_detail::flat_tree<Key,
std::pair<Key, T>,
containers_detail::select1st< std::pair<Key, T> >,
@@ -932,21 +932,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- flat_multimap(BOOST_MOVE_MACRO_RV_REF(flat_multimap) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_multimap(BOOST_RV_REF(flat_multimap) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
{ }
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multimap) x)
+ flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
{ m_flat_tree = x.m_flat_tree; return *this; }
//! <b>Effects</b>: this->swap(x.get()).
//!
//! <b>Complexity</b>: Constant.
- flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multimap) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_multimap<Key,T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_multimap) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -1093,8 +1093,8 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return force_copy<iterator>(m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
//! <b>Effects</b>: Inserts a new value move-constructed from x and returns
//! the iterator pointing to the newly inserted element.
@@ -1103,8 +1103,8 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
- { return force_copy<iterator>(m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ iterator insert(BOOST_RV_REF(impl_value_type) x)
+ { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
//! <b>Effects</b>: Inserts a copy of x in the container.
//! p is a hint pointing to where the insert should start to search.
@@ -1131,11 +1131,11 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
{
return force_copy<iterator>
(m_flat_tree.insert_equal(force<impl_const_iterator>(position)
- , BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ , boost::move(x)));
}
//! <b>Effects</b>: Inserts a value move constructed from x in the container.
@@ -1149,10 +1149,10 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(impl_value_type) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
{
return force_copy<iterator>(
- m_flat_tree.insert_equal(force<impl_const_iterator>(position), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)));
+ m_flat_tree.insert_equal(force<impl_const_iterator>(position), boost::move(x)));
}
//! <b>Requires</b>: i, j are not iterators into *this.
@@ -1179,7 +1179,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace(Args&&... args)
- { return force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)); }
+ { return force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... in the container.
@@ -1197,7 +1197,7 @@
iterator emplace_hint(const_iterator hint, Args&&... args)
{
return force_copy<iterator>(m_flat_tree.emplace_hint_equal
- (force<impl_const_iterator>(hint), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...));
+ (force<impl_const_iterator>(hint), boost::forward<Args>(args)...));
}
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -24,7 +24,7 @@
#include <memory>
#include INCLUDE_BOOST_CONTAINER_DETAIL_FLAT_TREE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -65,7 +65,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_set)
+ BOOST_COPYABLE_AND_MOVABLE(flat_set)
typedef containers_detail::flat_tree<T, T, containers_detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_flat_tree; // flat tree representing flat_set
typedef typename containers_detail::
@@ -139,21 +139,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- flat_set(BOOST_MOVE_MACRO_RV_REF(flat_set) mx)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree))
+ flat_set(BOOST_RV_REF(flat_set) mx)
+ : m_flat_tree(boost::move(mx.m_flat_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- flat_set<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_set) x)
+ flat_set<T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
{ m_flat_tree = x.m_flat_tree; return *this; }
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- flat_set<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_set) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_set<T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_set) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -336,7 +336,7 @@
{ return this->insert(const_cast<const T &>(x)); }
template<class U>
- std::pair<iterator, bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ std::pair<iterator, bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(u); }
#endif
@@ -351,8 +351,8 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_unique(boost::move(x)); }
//! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
//! no element in the container with key equivalent to the key of x.
@@ -373,7 +373,7 @@
{ return this->insert(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::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.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_unique(position, boost::move(x)); }
//! <b>Requires</b>: i, j are not iterators into *this.
//!
@@ -418,7 +418,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace(Args&&... args)
- { return m_flat_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }
//! <b>Effects</b>: 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 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -685,7 +685,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(flat_multiset)
+ BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
typedef containers_detail::flat_tree<T, T, containers_detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_flat_tree; // flat tree representing flat_multiset
typedef typename containers_detail::
@@ -740,15 +740,15 @@
flat_multiset(const flat_multiset<T,Pred,Alloc>& x)
: m_flat_tree(x.m_flat_tree) {}
- flat_multiset(BOOST_MOVE_MACRO_RV_REF(flat_multiset) x)
- : m_flat_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_flat_tree))
+ flat_multiset(BOOST_RV_REF(flat_multiset) x)
+ : m_flat_tree(boost::move(x.m_flat_tree))
{}
- flat_multiset<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(flat_multiset) x)
+ flat_multiset<T,Pred,Alloc>& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
{ m_flat_tree = x.m_flat_tree; return *this; }
- flat_multiset<T,Pred,Alloc>& operator=(BOOST_MOVE_MACRO_RV_REF(flat_multiset) mx)
- { m_flat_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(mx.m_flat_tree); return *this; }
+ flat_multiset<T,Pred,Alloc>& operator=(BOOST_RV_REF(flat_multiset) mx)
+ { m_flat_tree = boost::move(mx.m_flat_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -927,7 +927,7 @@
{ return this->insert(const_cast<const T &>(x)); }
template<class U>
- iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(u); }
#endif
@@ -938,8 +938,8 @@
//! to the elements with bigger keys than x.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_equal(boost::move(x)); }
//! <b>Effects</b>: Inserts a copy of x in the container.
//! p is a hint pointing to where the insert should start to search.
@@ -959,7 +959,7 @@
{ return this->insert(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::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.
//!
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_flat_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
+ { return m_flat_tree.insert_equal(position, boost::move(x)); }
//! <b>Requires</b>: i, j are not iterators into *this.
//!
@@ -1000,7 +1000,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace(Args&&... args)
- { return m_flat_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... in the container.
@@ -1015,7 +1015,7 @@
//! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_flat_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
Modified: trunk/boost/interprocess/containers/container/list.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/list.hpp (original)
+++ trunk/boost/interprocess/containers/container/list.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -18,7 +18,8 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
+#include <boost/move/move_helpers.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
@@ -72,7 +73,7 @@
template<class ...Args>
list_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
{}
#else //#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -131,8 +132,6 @@
<A, typename containers_detail::intrusive_list_type<A>::type>
{
/// @cond
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
typedef typename
containers_detail::intrusive_list_type<A>::type Icont;
typedef list <T, A> ThisType;
@@ -198,7 +197,7 @@
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(list)
+ BOOST_COPYABLE_AND_MOVABLE(list)
typedef difference_type list_difference_type;
typedef pointer list_pointer;
typedef const_pointer list_const_pointer;
@@ -357,8 +356,8 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- list(BOOST_MOVE_MACRO_RV_REF(list) x)
- : AllocHolder(BOOST_CONTAINER_MOVE_NAMESPACE::move(static_cast<AllocHolder&>(x)))
+ list(BOOST_RV_REF(list) x)
+ : AllocHolder(boost::move(static_cast<AllocHolder&>(x)))
{}
//! <b>Effects</b>: Constructs a list that will use a copy of allocator a
@@ -530,56 +529,46 @@
size_type max_size() const
{ return AllocHolder::max_size(); }
- //! <b>Effects</b>: Inserts a copy of t in the beginning of the list.
+
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! <b>Effects</b>: Inserts a copy of x at the beginning of the list.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's copy constructor throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_front(insert_const_ref_type x)
- { this->insert(this->cbegin(), x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_front(T &x) { push_front(const_cast<const T &>(x)); }
-
- template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { this->insert(this->cbegin(), u); }
- #endif
+ void push_front(const T &x);
//! <b>Effects</b>: Constructs a new element in the beginning of the list
- //! and moves the resources of t to this new element.
+ //! and moves the resources of mx to this new element.
//!
//! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_front(BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->insert(this->cbegin(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ void push_front(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_front, T, void, priv_push_front)
+ #endif
- //! <b>Effects</b>: Removes the last element from the list.
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! <b>Effects</b>: Inserts a copy of x at the end of the list.
//!
- //! <b>Throws</b>: Nothing.
+ //! <b>Throws</b>: If memory allocation throws or
+ //! T's copy constructor throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_back (insert_const_ref_type x)
- { this->insert(this->cend(), x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- void push_back(T &x) { push_back(const_cast<const T &>(x)); }
-
- template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { this->insert(this->cend(), u); }
-
- #endif
+ void push_back(const T &x);
- //! <b>Effects</b>: Removes the first element from the list.
+ //! <b>Effects</b>: Constructs a new element in the end of the list
+ //! and moves the resources of mx to this new element.
//!
- //! <b>Throws</b>: Nothing.
+ //! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_back (BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
+ #endif
//! <b>Effects</b>: Removes the first element from the list.
//!
@@ -716,7 +705,7 @@
//! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
//!
//! <b>Complexity</b>: Linear to the number of elements in x.
- ThisType& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(ThisType) x)
+ ThisType& operator=(BOOST_COPY_ASSIGN_REF(ThisType) x)
{
if (this != &x) {
this->assign(x.begin(), x.end());
@@ -732,7 +721,7 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- ThisType& operator=(BOOST_MOVE_MACRO_RV_REF(ThisType) mx)
+ ThisType& operator=(BOOST_RV_REF(ThisType) mx)
{
this->clear();
this->swap(mx);
@@ -760,41 +749,32 @@
template <class InpIt>
void insert(const_iterator p, InpIt first, InpIt last)
{
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_insert_dispatch(p, first, last, Result());
}
- //! <b>Requires</b>: p must be a valid iterator of *this.
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! <b>Requires</b>: position must be a valid iterator of *this.
//!
- //! <b>Effects</b>: Insert a copy of x before p.
+ //! <b>Effects</b>: Insert a copy of x before position.
//!
//! <b>Throws</b>: If memory allocation throws or x's copy constructor throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x) { return this->insert(position, const_cast<const T &>(x)); }
+ iterator insert(const_iterator position, const T &x);
- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
-
- //! <b>Requires</b>: p must be a valid iterator of *this.
+ //! <b>Requires</b>: position must be a valid iterator of *this.
//!
- //! <b>Effects</b>: Insert a new element before p with mx's resources.
+ //! <b>Effects</b>: Insert a new element before position with mx's resources.
//!
//! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(T) x)
- {
- NodePtr tmp = AllocHolder::create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
- return iterator(this->icont().insert(p.get(), *tmp));
- }
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif
#if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -808,7 +788,7 @@
template <class... Args>
void emplace_back(Args&&... args)
{
- this->emplace(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace(this->cend(), boost::forward<Args>(args)...);
}
//! <b>Effects</b>: Inserts an object of type T constructed with
@@ -821,7 +801,7 @@
template <class... Args>
void emplace_front(Args&&... args)
{
- this->emplace(this->cbegin(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ this->emplace(this->cbegin(), boost::forward<Args>(args)...);
}
//! <b>Effects</b>: Inserts an object of type T constructed with
@@ -835,7 +815,7 @@
iterator emplace(const_iterator p, Args&&... args)
{
typename AllocHolder::Deallocator d(AllocHolder::create_node_and_deallocator());
- new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(boost::forward<Args>(args)...);
NodePtr node = d.get();
d.release();
return iterator(this->icont().insert(p.get(), *node));
@@ -923,7 +903,7 @@
template <class InpIt>
void assign(InpIt first, InpIt last)
{
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_assign_dispatch(first, last, Result());
}
@@ -1166,6 +1146,24 @@
return iterator(this->icont().insert(p.get(), *tmp));
}
+ iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x)
+ {
+ NodePtr tmp = AllocHolder::create_node(boost::move(x));
+ return iterator(this->icont().insert(p.get(), *tmp));
+ }
+
+ void priv_push_back (const T &x)
+ { this->insert(this->cend(), x); }
+
+ void priv_push_back (BOOST_RV_REF(T) x)
+ { this->insert(this->cend(), boost::move(x)); }
+
+ void priv_push_front (const T &x)
+ { this->insert(this->cbegin(), x); }
+
+ void priv_push_front (BOOST_RV_REF(T) x)
+ { this->insert(this->cbegin(), boost::move(x)); }
+
//Iterator range version
template<class InpIterator>
void priv_create_and_insert_nodes
Modified: trunk/boost/interprocess/containers/container/map.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/map.hpp (original)
+++ trunk/boost/interprocess/containers/container/map.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -61,7 +61,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_PAIR_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -99,7 +99,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(map)
+ BOOST_COPYABLE_AND_MOVABLE(map)
typedef containers_detail::rbtree<Key,
std::pair<const Key, T>,
containers_detail::select1st< std::pair<const Key, T> >,
@@ -193,21 +193,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- map(BOOST_MOVE_MACRO_RV_REF(map) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ map(BOOST_RV_REF(map) x)
+ : m_tree(boost::move(x.m_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- map& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(map) x)
+ map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
{ m_tree = x.m_tree; return *this; }
//! <b>Effects</b>: this->swap(x.get()).
//!
//! <b>Complexity</b>: Constant.
- map& operator=(BOOST_MOVE_MACRO_RV_REF(map) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ map& operator=(BOOST_RV_REF(map) x)
+ { m_tree = boost::move(x.m_tree); return *this; }
//! <b>Effects</b>: 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_CONTAINER_MOVE_NAMESPACE::move(v.m_t));
- i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ value_type val(k, boost::move(v.m_t));
+ i = insert(i, boost::move(val));
}
return (*i).second;
}
//! Effects: If there is no key equivalent to x in the map, inserts
- //! value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x), T()) into the map (the key is move-constructed)
+ //! value_type(boost::move(x), T()) into the map (the key is move-constructed)
//!
//! Returns: A reference to the mapped_type corresponding to x in *this.
//!
//! Complexity: Logarithmic.
- T& operator[](BOOST_MOVE_MACRO_RV_REF(key_type) mk)
+ T& operator[](BOOST_RV_REF(key_type) mk)
{
key_type &k = mk;
//we can optimize this
iterator i = lower_bound(k);
// i->first is greater than or equivalent to k.
if (i == end() || key_comp()(k, (*i).first)){
- value_type val(BOOST_CONTAINER_MOVE_NAMESPACE::move(k), BOOST_CONTAINER_MOVE_NAMESPACE::move(T()));
- i = insert(i, BOOST_CONTAINER_MOVE_NAMESPACE::move(val));
+ value_type val(boost::move(k), boost::move(T()));
+ i = insert(i, boost::move(val));
}
return (*i).second;
}
@@ -429,8 +429,8 @@
//! points to the element with key equivalent to the key of x.
//!
//! <b>Complexity</b>: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }
//! <b>Effects</b>: 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.
//!
//! <b>Complexity</b>: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }
//! <b>Effects</b>: 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.
//!
//! <b>Complexity</b>: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }
//! <b>Effects</b>: 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 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }
//! <b>Effects</b>: 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 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }
//! <b>Effects</b>: 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 @@
//! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
//!
//! <b>Complexity</b>: Logarithmic.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(position, boost::move(x)); }
//! <b>Requires</b>: 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_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_unique(boost::forward<Args>(args)...); }
//! <b>Effects</b>: 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_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -752,7 +752,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(multimap)
+ BOOST_COPYABLE_AND_MOVABLE(multimap)
typedef containers_detail::rbtree<Key,
std::pair<const Key, T>,
containers_detail::select1st< std::pair<const Key, T> >,
@@ -847,21 +847,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- multimap(BOOST_MOVE_MACRO_RV_REF(multimap) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ multimap(BOOST_RV_REF(multimap) x)
+ : m_tree(boost::move(x.m_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- multimap& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multimap) x)
+ multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x)
{ m_tree = x.m_tree; return *this; }
//! <b>Effects</b>: this->swap(x.get()).
//!
//! <b>Complexity</b>: Constant.
- multimap& operator=(BOOST_MOVE_MACRO_RV_REF(multimap) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ multimap& operator=(BOOST_RV_REF(multimap) x)
+ { m_tree = boost::move(x.m_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -1009,15 +1009,15 @@
//! the iterator pointing to the newly inserted element.
//!
//! <b>Complexity</b>: Logarithmic.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }
//! <b>Effects</b>: Inserts a new value move-constructed from x and returns
//! the iterator pointing to the newly inserted element.
//!
//! <b>Complexity</b>: Logarithmic.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }
//! <b>Effects</b>: 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 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_value_type) x)
- { return m_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
+ { return m_tree.insert_equal(position, boost::move(x)); }
//! <b>Effects</b>: 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 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(iterator position, BOOST_MOVE_MACRO_RV_REF(nonconst_impl_value_type) x)
- { return m_tree.insert_equal(position, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x)
+ { return m_tree.insert_equal(position, boost::move(x)); }
//! <b>Requires</b>: 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_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
//! <b>Effects</b>: 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_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
Modified: trunk/boost/interprocess/containers/container/set.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/set.hpp (original)
+++ trunk/boost/interprocess/containers/container/set.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -23,10 +23,10 @@
#include <functional>
#include <memory>
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_TREE_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#ifndef BOOST_CONTAINERS_PERFECT_FORWARDING
#include INCLUDE_BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
#endif
@@ -62,7 +62,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(set)
+ BOOST_COPYABLE_AND_MOVABLE(set)
typedef containers_detail::rbtree<T, T,
containers_detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_tree; // red-black tree representing set
@@ -136,21 +136,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- set(BOOST_MOVE_MACRO_RV_REF(set) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ set(BOOST_RV_REF(set) x)
+ : m_tree(boost::move(x.m_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- set& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(set) x)
+ set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
{ m_tree = x.m_tree; return *this; }
//! <b>Effects</b>: this->swap(x.get()).
//!
//! <b>Complexity</b>: Constant.
- set& operator=(BOOST_MOVE_MACRO_RV_REF(set) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ set& operator=(BOOST_RV_REF(set) x)
+ { m_tree = boost::move(x.m_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -330,7 +330,7 @@
{ return this->insert(const_cast<const T &>(x)); }
template<class U>
- std::pair<iterator,bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ std::pair<iterator,bool> insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(u); }
#endif
@@ -342,8 +342,8 @@
//! points to the element with key equivalent to the key of x.
//!
//! <b>Complexity</b>: Logarithmic.
- std::pair<iterator,bool> insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(boost::move(x)); }
//! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
//! no element in the container with key equivalent to the key of x.
@@ -362,7 +362,7 @@
{ return this->insert(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(position, u); }
#endif
@@ -372,8 +372,8 @@
//! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
//!
//! <b>Complexity</b>: Logarithmic.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_unique(p, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_unique(p, boost::move(x)); }
//! <b>Requires</b>: i, j are not iterators into *this.
//!
@@ -399,7 +399,7 @@
//! <b>Complexity</b>: Logarithmic.
template <class... Args>
iterator emplace(Args&&... args)
- { return m_tree.emplace_unique(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_unique(boost::forward<Args>(args)...); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... if and only if there is
@@ -412,7 +412,7 @@
//! <b>Complexity</b>: Logarithmic.
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_unique(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -620,7 +620,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(multiset)
+ BOOST_COPYABLE_AND_MOVABLE(multiset)
typedef containers_detail::rbtree<T, T,
containers_detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_tree; // red-black tree representing multiset
@@ -695,21 +695,21 @@
//! <b>Complexity</b>: Construct.
//!
//! <b>Postcondition</b>: x is emptied.
- multiset(BOOST_MOVE_MACRO_RV_REF(multiset) x)
- : m_tree(BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree))
+ multiset(BOOST_RV_REF(multiset) x)
+ : m_tree(boost::move(x.m_tree))
{}
//! <b>Effects</b>: Makes *this a copy of x.
//!
//! <b>Complexity</b>: Linear in x.size().
- multiset& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(multiset) x)
+ multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
{ m_tree = x.m_tree; return *this; }
//! <b>Effects</b>: this->swap(x.get()).
//!
//! <b>Complexity</b>: Constant.
- multiset& operator=(BOOST_MOVE_MACRO_RV_REF(multiset) x)
- { m_tree = BOOST_CONTAINER_MOVE_NAMESPACE::move(x.m_tree); return *this; }
+ multiset& operator=(BOOST_RV_REF(multiset) x)
+ { m_tree = boost::move(x.m_tree); return *this; }
//! <b>Effects</b>: Returns the comparison object out
//! of which a was constructed.
@@ -885,7 +885,7 @@
{ return this->insert(const_cast<const T &>(x)); }
template<class U>
- iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(u); }
#endif
@@ -896,8 +896,8 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_equal(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_equal(boost::move(x)); }
//! <b>Effects</b>: Inserts a copy of x in the container.
//! p is a hint pointing to where the insert should start to search.
@@ -915,7 +915,7 @@
{ return this->insert(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_insert(position, u); }
#endif
@@ -927,8 +927,8 @@
//!
//! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
//! is inserted right before p.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return m_tree.insert_equal(p, BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return m_tree.insert_equal(p, boost::move(x)); }
//! <b>Requires</b>: i, j are not iterators into *this.
//!
@@ -948,7 +948,7 @@
//! <b>Complexity</b>: Logarithmic.
template <class... Args>
iterator emplace(Args&&... args)
- { return m_tree.emplace_equal(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_equal(boost::forward<Args>(args)...); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)...
@@ -960,7 +960,7 @@
//! is inserted right before p.
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
- { return m_tree.emplace_hint_equal(hint, BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
Modified: trunk/boost/interprocess/containers/container/slist.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/slist.hpp (original)
+++ trunk/boost/interprocess/containers/container/slist.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -19,7 +19,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
@@ -73,7 +73,7 @@
template<class ...Args>
slist_node(Args &&...args)
- : m_data(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : m_data(boost::forward<Args>(args)...)
{}
#else //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -222,7 +222,7 @@
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(slist)
+ BOOST_COPYABLE_AND_MOVABLE(slist)
typedef difference_type list_difference_type;
typedef pointer list_pointer;
typedef const_pointer list_const_pointer;
@@ -372,8 +372,8 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- slist(BOOST_MOVE_MACRO_RV_REF(slist) x)
- : AllocHolder(BOOST_CONTAINER_MOVE_NAMESPACE::move((AllocHolder&)x))
+ slist(BOOST_RV_REF(slist) x)
+ : AllocHolder(boost::move((AllocHolder&)x))
{}
//! <b>Effects</b>: Makes *this contain the same elements as x.
@@ -384,7 +384,7 @@
//! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
//!
//! <b>Complexity</b>: Linear to the number of elements in x.
- slist& operator= (BOOST_MOVE_MACRO_COPY_ASSIGN_REF(slist) x)
+ slist& operator= (BOOST_COPY_ASSIGN_REF(slist) x)
{
if (&x != this){
this->assign(x.begin(), x.end());
@@ -400,7 +400,7 @@
//! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
//!
//! <b>Complexity</b>: Linear to the number of elements in x.
- slist& operator= (BOOST_MOVE_MACRO_RV_REF(slist) mx)
+ slist& operator= (BOOST_RV_REF(slist) mx)
{
if (&mx != this){
this->clear();
@@ -451,7 +451,7 @@
template <class InpIt>
void assign(InpIt first, InpIt last)
{
- const bool aux_boolean = containers_detail::is_convertible<InpIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InpIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_assign_dispatch(first, last, Result());
}
@@ -603,7 +603,7 @@
void push_front(T &x) { push_front(const_cast<const T &>(x)); }
template<class U>
- void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ void push_front(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_push_front(u); }
#endif
@@ -613,8 +613,8 @@
//! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_front(BOOST_MOVE_MACRO_RV_REF(T) x)
- { this->icont().push_front(*this->create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x))); }
+ void push_front(BOOST_RV_REF(T) x)
+ { this->icont().push_front(*this->create_node(boost::move(x))); }
//! <b>Effects</b>: Removes the first element from the list.
//!
@@ -665,7 +665,7 @@
{ return this->insert_after(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert_after(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert_after(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return this->priv_insert_after(position, u); }
#endif
@@ -682,8 +682,8 @@
//!
//! <b>Note</b>: Does not affect the validity of iterators and references of
//! previous values.
- iterator insert_after(const_iterator prev_pos, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(BOOST_CONTAINER_MOVE_NAMESPACE::move(x)))); }
+ iterator insert_after(const_iterator prev_pos, BOOST_RV_REF(value_type) x)
+ { return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(boost::move(x)))); }
//! <b>Requires</b>: prev_pos must be a valid iterator of *this.
//!
@@ -713,7 +713,7 @@
template <class InIter>
void insert_after(const_iterator prev_pos, InIter first, InIter last)
{
- const bool aux_boolean = containers_detail::is_convertible<InIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIter, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_insert_after_range_dispatch(prev_pos, first, last, Result());
}
@@ -733,7 +733,7 @@
{ return this->insert(position, const_cast<const T &>(x)); }
template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return this->priv_insert(position, u); }
#endif
@@ -744,8 +744,8 @@
//! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Linear to the elements before p.
- iterator insert(const_iterator p, BOOST_MOVE_MACRO_RV_REF(value_type) x)
- { return this->insert_after(previous(p), BOOST_CONTAINER_MOVE_NAMESPACE::move(x)); }
+ iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+ { return this->insert_after(previous(p), boost::move(x)); }
//! <b>Requires</b>: p must be a valid iterator of *this.
//!
@@ -781,7 +781,7 @@
//! <b>Complexity</b>: Amortized constant time.
template <class... Args>
void emplace_front(Args&&... args)
- { this->emplace_after(this->cbefore_begin(), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { this->emplace_after(this->cbefore_begin(), boost::forward<Args>(args)...); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... before p
@@ -792,7 +792,7 @@
//! <b>Complexity</b>: Linear to the elements before p
template <class... Args>
iterator emplace(const_iterator p, Args&&... args)
- { return this->emplace_after(this->previous(p), BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...); }
+ { return this->emplace_after(this->previous(p), boost::forward<Args>(args)...); }
//! <b>Effects</b>: Inserts an object of type T constructed with
//! std::forward<Args>(args)... after prev
@@ -805,7 +805,7 @@
iterator emplace_after(const_iterator prev, Args&&... args)
{
typename AllocHolder::Deallocator d(AllocHolder::create_node_and_deallocator());
- new ((void*)containers_detail::get_pointer(d.get())) Node(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new ((void*)containers_detail::get_pointer(d.get())) Node(boost::forward<Args>(args)...);
NodePtr node = d.get();
d.release();
return iterator(this->icont().insert_after(prev.get(), *node));
@@ -1338,7 +1338,7 @@
template<class Integer>
void priv_insert_dispatch(const_iterator prev, Integer n, Integer x, containers_detail::true_)
- { this->priv_create_and_insert_nodes(prev, (std::size_t)n, x); }
+ { this->priv_create_and_insert_nodes(prev, (size_type)n, x); }
void priv_fill_assign(size_type n, const T& val)
{
@@ -1380,7 +1380,7 @@
template <class Int>
void priv_insert_after_range_dispatch(const_iterator prev_pos, Int n, Int x, containers_detail::true_)
- { this->priv_create_and_insert_nodes(prev_pos, (std::size_t)n, x); }
+ { this->priv_create_and_insert_nodes(prev_pos, (size_type)n, x); }
template <class InIter>
void priv_insert_after_range_dispatch(const_iterator prev_pos, InIter first, InIter last, containers_detail::false_)
Modified: 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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -140,7 +140,7 @@
template<class ...Args>
node_type(Args &&...args)
- : value(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...)
+ : value(boost::forward<Args>(args)...)
{}
#else //BOOST_CONTAINERS_PERFECT_FORWARDING
@@ -225,9 +225,9 @@
{ pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)+1)); }
void decrement()
{ pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)-1)); }
- void advance(std::ptrdiff_t n)
+ void advance(difference_type n)
{ pn = node_ptr_cast(*(void_ptr_ptr_cast(pn->up)+n)); }
- std::ptrdiff_t distance_to(const iterator& x)const
+ difference_type distance_to(const iterator& x)const
{ return void_ptr_ptr_cast(x.pn->up) - void_ptr_ptr_cast(pn->up); }
public:
@@ -454,7 +454,7 @@
///@cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(stable_vector)
+ BOOST_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_MOVE_MACRO_RV_REF(stable_vector) x)
+ stable_vector(BOOST_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_MOVE_MACRO_COPY_ASSIGN_REF(stable_vector) x)
+ stable_vector& operator=(BOOST_COPY_ASSIGN_REF(stable_vector) x)
{
STABLE_VECTOR_CHECK_INVARIANT;
if (this != &x) {
@@ -527,7 +527,7 @@
return *this;
}
- stable_vector& operator=(BOOST_MOVE_MACRO_RV_REF(stable_vector) x)
+ stable_vector& operator=(BOOST_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_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ void push_back(const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return priv_push_back(u); }
#endif
- void push_back(BOOST_MOVE_MACRO_RV_REF(T) t)
- { this->insert(end(), BOOST_CONTAINER_MOVE_NAMESPACE::move(t)); }
+ void push_back(BOOST_RV_REF(T) t)
+ { this->insert(end(), boost::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_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
+ iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0)
{ return this->priv_insert(position, u); }
#endif
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x)
+ iterator insert(const_iterator position, BOOST_RV_REF(T) x)
{
typedef repeat_iterator<T, difference_type> repeat_it;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<repeat_it> repeat_move_it;
+ typedef boost::move_iterator<repeat_it> repeat_move_it;
//Just call more general insert(pos, size, value) and return iterator
size_type pos_n = position - cbegin();
this->insert(position
@@ -735,8 +735,8 @@
void emplace_back(Args &&...args)
{
typedef emplace_functor<node_type_t, Args...> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
- EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
+ EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
}
@@ -755,8 +755,8 @@
//Just call more general insert(pos, size, value) and return iterator
size_type pos_n = position - cbegin();
typedef emplace_functor<node_type_t, Args...> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
- EmplaceFunctor &&ef = EmplaceFunctor(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
+ EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
this->insert(position, EmplaceIterator(ef), EmplaceIterator());
return iterator(this->begin() + pos_n);
}
@@ -766,7 +766,7 @@
void emplace_back()
{
typedef emplace_functor<node_type_t> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
EmplaceFunctor ef;
this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
}
@@ -774,7 +774,7 @@
iterator emplace(const_iterator position)
{
typedef emplace_functor<node_type_t> EmplaceFunctor;
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator;
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator;
EmplaceFunctor ef;
size_type pos_n = position - this->cbegin();
this->insert(position, EmplaceIterator(ef), EmplaceIterator());
@@ -787,7 +787,7 @@
{ \
typedef BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg) \
<node_type_t, BOOST_PP_ENUM_PARAMS(n, P)> EmplaceFunctor; \
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator; \
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator; \
EmplaceFunctor ef(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator()); \
} \
@@ -797,7 +797,7 @@
{ \
typedef BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg) \
<node_type_t, BOOST_PP_ENUM_PARAMS(n, P)> EmplaceFunctor; \
- typedef emplace_iterator<node_type_t, EmplaceFunctor> EmplaceIterator; \
+ typedef emplace_iterator<node_type_t, EmplaceFunctor, difference_type> EmplaceIterator; \
EmplaceFunctor ef(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
size_type pos_n = pos - this->cbegin(); \
this->insert(pos, EmplaceIterator(ef), EmplaceIterator()); \
@@ -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_CONTAINER_MOVE_NAMESPACE::move(holder));
+ get_al().deallocate_individual(boost::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_CONTAINER_MOVE_NAMESPACE::is_movable<multiallocation_chain>::value == true));
+ //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<multiallocation_chain>::value == true));
multiallocation_chain m (get_al().allocate_individual(n));
holder.splice_after(holder.before_begin(), m, m.before_begin(), m.last(), n);
this->internal_data.pool_size += n;
@@ -1169,7 +1169,7 @@
}
catch(...){
get_al().deallocate_one(p);
- get_al().deallocate_many(BOOST_CONTAINER_MOVE_NAMESPACE::move(mem));
+ get_al().deallocate_many(boost::move(mem));
impl.erase(it+i, it+n);
this->align_nodes(it+i,get_last_align());
throw;
Modified: trunk/boost/interprocess/containers/container/string.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/string.hpp (original)
+++ trunk/boost/interprocess/containers/container/string.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -22,7 +22,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/static_assert.hpp>
#include <functional>
@@ -42,6 +42,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/aligned_storage.hpp>
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
namespace boost {
@@ -67,7 +68,7 @@
class basic_string_base
{
basic_string_base();
- BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_string_base)
public:
typedef A allocator_type;
@@ -81,14 +82,14 @@
: members_(a)
{ init(); }
- basic_string_base(const allocator_type& a, std::size_t n)
+ basic_string_base(const allocator_type& a, size_type n)
: members_(a)
{
this->init();
this->allocate_initial_block(n);
}
- basic_string_base(BOOST_MOVE_MACRO_RV_REF(basic_string_base) b)
+ basic_string_base(BOOST_RV_REF(basic_string_base) b)
: members_(b.members_)
{
init();
@@ -134,14 +135,6 @@
}
};
- //This basic type should have the same alignment as long_t
-//iG typedef typename type_with_alignment<containers_detail::alignment_of<long_t>::value>::type
-// long_alignment_type;
- typedef void *long_alignment_type;
- BOOST_STATIC_ASSERT((containers_detail::alignment_of<long_alignment_type>::value %
- containers_detail::alignment_of<long_t>::value) == 0);
-
-
//This type is the first part of the structure controlling a short string
//The "data" member stores
struct short_header
@@ -152,11 +145,9 @@
//This type has the same alignment and size as long_t but it's POD
//so, unlike long_t, it can be placed in a union
- struct long_raw_t
- {
- long_alignment_type a;
- unsigned char b[sizeof(long_t) - sizeof(long_alignment_type)];
- };
+
+ typedef typename boost::aligned_storage< sizeof(long_t),
+ containers_detail::alignment_of<long_t>::value>::type long_raw_t;
protected:
static const size_type MinInternalBufferChars = 8;
@@ -284,7 +275,7 @@
size_type next_capacity(size_type additional_objects) const
{ return get_next_capacity(this->alloc().max_size(), this->priv_storage(), additional_objects); }
- void deallocate(pointer p, std::size_t n)
+ void deallocate(pointer p, size_type n)
{
if (p && (n > InternalBufferChars))
this->alloc().deallocate(p, n);
@@ -302,7 +293,7 @@
void destroy(pointer p)
{ containers_detail::get_pointer(p)->~value_type(); }
- void allocate_initial_block(std::size_t n)
+ void allocate_initial_block(size_type n)
{
if (n <= this->max_size()) {
if(n > InternalBufferChars){
@@ -321,7 +312,7 @@
void deallocate_block()
{ this->deallocate(this->priv_addr(), this->priv_storage()); }
- std::size_t max_size() const
+ size_type max_size() const
{ return this->alloc().max_size() - 1; }
// Helper functions for exception handling.
@@ -429,7 +420,7 @@
{
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(basic_string)
+ BOOST_COPYABLE_AND_MOVABLE(basic_string)
typedef containers_detail::basic_string_base<A> base_t;
static const typename base_t::size_type InternalBufferChars = base_t::InternalBufferChars;
@@ -509,7 +500,7 @@
struct reserve_t {};
/// @endcond
- basic_string(reserve_t, std::size_t n,
+ basic_string(reserve_t, size_type n,
const allocator_type& a = allocator_type())
: base_t(a, n + 1)
{ this->priv_terminate_string(); }
@@ -535,8 +526,8 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- basic_string(BOOST_MOVE_MACRO_RV_REF(basic_string) s)
- : base_t(BOOST_CONTAINER_MOVE_NAMESPACE::move((base_t&)s))
+ basic_string(BOOST_RV_REF(basic_string) s)
+ : base_t(boost::move((base_t&)s))
{}
//! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
@@ -584,7 +575,7 @@
: base_t(a)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIterator, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIterator, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_initialize_dispatch(f, l, Result());
}
@@ -602,7 +593,7 @@
//! <b>Postcondition</b>: x == *this.
//!
//! <b>Complexity</b>: Linear to the elements x contains.
- basic_string& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(basic_string) s)
+ basic_string& operator=(BOOST_COPY_ASSIGN_REF(basic_string) s)
{
if (&s != this)
this->assign(s.begin(), s.end());
@@ -614,7 +605,7 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- basic_string& operator=(BOOST_MOVE_MACRO_RV_REF(basic_string) ms)
+ basic_string& operator=(BOOST_RV_REF(basic_string) ms)
{
basic_string &s = ms;
if (&s != this){
@@ -931,7 +922,7 @@
{ return this->operator=(s); }
//! <b>Effects</b>: Moves the resources from ms *this.
- basic_string& assign(BOOST_MOVE_MACRO_RV_REF(basic_string) ms)
+ basic_string& assign(BOOST_RV_REF(basic_string) ms)
{ return this->operator=(ms);}
//! <b>Effects</b>: Assigns the range [pos, pos + n) from s to *this.
@@ -960,7 +951,7 @@
basic_string& assign(InputIter first, InputIter last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
return this->priv_assign_dispatch(first, last, Result());
}
@@ -1050,7 +1041,7 @@
}
//! <b>Effects</b>: Inserts the character c n-times before position.
- void insert(iterator position, std::size_t n, CharT c)
+ void insert(iterator position, size_type n, CharT c)
{
this->insert(position, cvalue_iterator(c, n),
cvalue_iterator());
@@ -1061,7 +1052,7 @@
void insert(iterator p, InputIter first, InputIter last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_insert_dispatch(p, first, last, Result());
}
@@ -1204,7 +1195,7 @@
InputIter f, InputIter l)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InputIter, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InputIter, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
return this->priv_replace_dispatch(first, last, f, l, Result());
}
@@ -1295,7 +1286,7 @@
//! substring of *this, beginning at character position min(pos, size()).
size_type rfind(const CharT* s, size_type pos, size_type n) const
{
- const std::size_t len = size();
+ const size_type len = size();
if (n > len)
return npos;
@@ -1540,8 +1531,8 @@
static int s_compare(const_pointer f1, const_pointer l1,
const_pointer f2, const_pointer l2)
{
- const std::ptrdiff_t n1 = l1 - f1;
- const std::ptrdiff_t n2 = l2 - f2;
+ const difference_type n1 = l1 - f1;
+ const difference_type n2 = l2 - f2;
const int cmp = Traits::compare(containers_detail::get_pointer(f1),
containers_detail::get_pointer(f2),
containers_detail::min_value(n1, n2));
@@ -1900,19 +1891,19 @@
}
template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
, const basic_string<CharT,Traits,A>& y)
{
mx += y;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
+ return boost::move(mx);
}
template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(const basic_string<CharT,Traits,A>& x,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
typedef typename basic_string<CharT,Traits,A>::size_type size_type;
return my.replace(size_type(0), size_type(0), x);
@@ -1922,10 +1913,10 @@
inline basic_string<CharT,Traits,A>
operator+(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
- typedef basic_string<CharT,Traits,A> str_t;
+ typedef basic_string<CharT, Traits, A> str_t;
typedef typename str_t::reserve_t reserve_t;
reserve_t reserve;
- const std::size_t n = Traits::length(s);
+ const typename str_t::size_type n = Traits::length(s);
str_t result(reserve, n + y.size());
result.append(s, s + n);
result.append(y);
@@ -1933,12 +1924,12 @@
}
template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(const CharT* s,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
typedef typename basic_string<CharT,Traits,A>::size_type size_type;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(my.get().replace(size_type(0), size_type(0), s));
+ return boost::move(my.get().replace(size_type(0), size_type(0), s));
}
template <class CharT, class Traits, class A>
@@ -1955,9 +1946,9 @@
}
template <class CharT, class Traits, class A> inline
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
operator+(CharT c,
- BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
+ BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) my)
{
typedef typename basic_string<CharT,Traits,A>::size_type size_type;
return my.replace(size_type(0), size_type(0), &c, &c + 1);
@@ -1970,7 +1961,7 @@
typedef basic_string<CharT,Traits,A> str_t;
typedef typename str_t::reserve_t reserve_t;
reserve_t reserve;
- const std::size_t n = Traits::length(s);
+ const typename str_t::size_type n = Traits::length(s);
str_t result(reserve, x.size() + n, x.alloc());
result.append(x);
result.append(s, s + n);
@@ -1978,12 +1969,12 @@
}
template <class CharT, class Traits, class A>
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+(BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+operator+(BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
, const CharT* s)
{
mx += s;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
+ return boost::move(mx);
}
template <class CharT, class Traits, class A>
@@ -2000,12 +1991,12 @@
}
template <class CharT, class Traits, class A>
-BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
-operator+( BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
+BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A)
+operator+( BOOST_RV_REF_3_TEMPL_ARGS(basic_string, CharT, Traits, A) mx
, const CharT c)
{
mx += c;
- return BOOST_CONTAINER_MOVE_NAMESPACE::move(mx);
+ return boost::move(mx);
}
// Operator== and operator!=
@@ -2023,7 +2014,7 @@
inline bool
operator==(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
- std::size_t n = Traits::length(s);
+ typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
return n == y.size() && Traits::compare(s, y.data(), n) == 0;
}
@@ -2031,7 +2022,7 @@
inline bool
operator==(const basic_string<CharT,Traits,A>& x, const CharT* s)
{
- std::size_t n = Traits::length(s);
+ typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
return x.size() == n && Traits::compare(x.data(), s, n) == 0;
}
@@ -2068,7 +2059,7 @@
operator<(const CharT* s, const basic_string<CharT,Traits,A>& y)
{
return y.compare(s) > 0;
-// std::size_t n = Traits::length(s);
+// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
// return basic_string<CharT,Traits,A>
// ::s_compare(s, s + n, y.begin(), y.end()) < 0;
}
@@ -2079,7 +2070,7 @@
const CharT* s)
{
return x.compare(s) < 0;
-// std::size_t n = Traits::length(s);
+// basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
// return basic_string<CharT,Traits,A>
// ::s_compare(x.begin(), x.end(), s, s + n) < 0;
}
@@ -2174,8 +2165,8 @@
if (sentry) {
ok = true;
- std::size_t n = s.size();
- std::size_t pad_len = 0;
+ typename basic_string<CharT,Traits,A>::size_type n = s.size();
+ typename basic_string<CharT,Traits,A>::size_type pad_len = 0;
const bool left = (os.flags() & std::ios::left) != 0;
const std::size_t w = os.width(0);
std::basic_streambuf<CharT, Traits>* buf = os.rdbuf();
@@ -2251,7 +2242,7 @@
std::basic_istream<CharT, Traits>&
getline(std::istream& is, basic_string<CharT,Traits,A>& s,CharT delim)
{
- std::size_t nread = 0;
+ typename basic_string<CharT,Traits,A>::size_type nread = 0;
typename std::basic_istream<CharT, Traits>::sentry sentry(is, true);
if (sentry) {
std::basic_streambuf<CharT, Traits>* buf = is.rdbuf();
Modified: trunk/boost/interprocess/containers/container/vector.hpp
==============================================================================
--- trunk/boost/interprocess/containers/container/vector.hpp (original)
+++ trunk/boost/interprocess/containers/container/vector.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -31,6 +31,7 @@
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
+#include <boost/move/move_helpers.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_VERSION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALLOCATION_TYPE_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
@@ -38,7 +39,7 @@
#include INCLUDE_BOOST_CONTAINER_DETAIL_ALGORITHMS_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_DESTROYERS_HPP
#include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
-#include INCLUDE_BOOST_CONTAINER_MOVE_HPP
+#include <boost/move/move.hpp>
#include <boost/pointer_to_other.hpp>
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP
#include INCLUDE_BOOST_CONTAINER_DETAIL_ADVANCED_INSERT_INT_HPP
@@ -375,8 +376,6 @@
/// @cond
typedef vector<T, A> self_t;
typedef containers_detail::vector_alloc_holder<A> base_t;
- typedef typename containers_detail::
- move_const_ref_type<T>::type insert_const_ref_type;
/// @endcond
public:
//! The type of object, T, stored in the vector
@@ -411,7 +410,7 @@
/// @cond
private:
- BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(vector)
+ BOOST_COPYABLE_AND_MOVABLE(vector)
typedef containers_detail::advanced_insert_aux_int<T, T*> advanced_insert_aux_int_t;
typedef containers_detail::vector_value_traits<value_type, A> value_traits;
@@ -421,7 +420,7 @@
typedef constant_iterator<T, difference_type> cvalue_iterator;
typedef repeat_iterator<T, difference_type> repeat_it;
- typedef BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<repeat_it> repeat_move_it;
+ typedef boost::move_iterator<repeat_it> repeat_move_it;
/// @endcond
public:
@@ -471,7 +470,7 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Constant.
- vector(BOOST_MOVE_MACRO_RV_REF(vector) mx)
+ vector(BOOST_RV_REF(vector) mx)
: base_t(static_cast<base_t&>(mx).alloc())
{ this->swap(mx); }
@@ -780,8 +779,8 @@
else{
//We will reuse insert code, so create a dummy input iterator
T *dummy_it(containers_detail::get_pointer(this->members_.m_start));
- containers_detail::advanced_insert_aux_proxy<T, BOOST_CONTAINER_MOVE_NAMESPACE::move_iterator<T*>, T*>
- proxy(::BOOST_CONTAINER_MOVE_NAMESPACE::make_move_iterator(dummy_it), ::BOOST_CONTAINER_MOVE_NAMESPACE::make_move_iterator(dummy_it));
+ containers_detail::advanced_insert_aux_proxy<T, boost::move_iterator<T*>, T*>
+ proxy(::boost::make_move_iterator(dummy_it), ::boost::make_move_iterator(dummy_it));
//Backwards (and possibly forward) expansion
if(ret.second){
#ifdef BOOST_CONTAINERS_VECTOR_ALLOC_STATS
@@ -818,7 +817,7 @@
//! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
//!
//! <b>Complexity</b>: Linear to the number of elements in x.
- vector& operator=(BOOST_MOVE_MACRO_COPY_ASSIGN_REF(vector) x)
+ vector& operator=(BOOST_COPY_ASSIGN_REF(vector) x)
{
if (&x != this){
this->assign(x.members_.m_start, x.members_.m_start + x.members_.m_size);
@@ -834,7 +833,7 @@
//! <b>Throws</b>: If allocator_type's copy constructor throws.
//!
//! <b>Complexity</b>: Linear.
- vector& operator=(BOOST_MOVE_MACRO_RV_REF(vector) x)
+ vector& operator=(BOOST_RV_REF(vector) x)
{
if (&x != this){
this->swap(x);
@@ -861,17 +860,32 @@
void assign(InIt first, InIt last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_assign_dispatch(first, last, Result());
}
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
//! <b>Effects</b>: Inserts a copy of x at the end of the vector.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's copy constructor throws.
//!
//! <b>Complexity</b>: Amortized constant time.
+ void push_back(const T &x);
+
+ //! <b>Effects</b>: Constructs a new element in the end of the vector
+ //! and moves the resources of mx to this new element.
+ //!
+ //! <b>Throws</b>: If memory allocation throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+ void push_back(T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
+ #endif
+
+/*
void push_back(insert_const_ref_type x)
{ return priv_push_back(x); }
@@ -879,11 +893,13 @@
void push_back(T &x) { push_back(const_cast<const T &>(x)); }
template<class U>
- void push_back(const U &u, typename containers_detail::enable_if_c
- <containers_detail::is_same<T, U>::value &&
- !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value
- >::type* =0)
+ typename containers_detail::enable_if_c
+ <!::boost::has_move_emulation_enabled<U>::value &&
+ containers_detail::is_same<T, U>::value
+ >::type
+ push_back(const U &u)
{ return priv_push_back(u); }
+
#endif
//! <b>Effects</b>: Constructs a new element in the end of the vector
@@ -892,17 +908,25 @@
//! <b>Throws</b>: If memory allocation throws.
//!
//! <b>Complexity</b>: Amortized constant time.
- void push_back(BOOST_MOVE_MACRO_RV_REF(T) x)
+ void push_back(BOOST_RV_REF(T) x)
{
if (this->members_.m_size < this->members_.m_capacity){
//There is more memory, just construct a new object at the end
- new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
+ new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(::boost::move(x));
++this->members_.m_size;
}
else{
- this->insert(this->cend(), BOOST_CONTAINER_MOVE_NAMESPACE::move(x));
+ this->insert(this->cend(), ::boost::move(x));
}
}
+*/
+ //! <b>Effects</b>: Constructs a new element in the end of the vector
+ //! and moves the resources of mx to this new element.
+ //!
+ //! <b>Throws</b>: If memory allocation throws.
+ //!
+ //! <b>Complexity</b>: Amortized constant time.
+
#if defined(BOOST_CONTAINERS_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -918,12 +942,12 @@
T* back_pos = containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size;
if (this->members_.m_size < this->members_.m_capacity){
//There is more memory, just construct a new object at the end
- new((void*)(back_pos))value_type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ new((void*)(back_pos))value_type(::boost::forward<Args>(args)...);
++this->members_.m_size;
}
else{
typedef containers_detail::advanced_insert_aux_emplace<T, T*, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(::boost::forward<Args>(args)...);
priv_range_insert(back_pos, 1, proxy);
}
}
@@ -943,7 +967,7 @@
//Just call more general insert(pos, size, value) and return iterator
size_type pos_n = position - cbegin();
typedef containers_detail::advanced_insert_aux_emplace<T, T*, Args...> type;
- type &&proxy = type(BOOST_CONTAINER_MOVE_NAMESPACE::forward<Args>(args)...);
+ type &&proxy = type(::boost::forward<Args>(args)...);
priv_range_insert(position.get_ptr(), 1, proxy);
return iterator(this->members_.m_start + pos_n);
}
@@ -974,30 +998,30 @@
#define BOOST_PP_LOCAL_MACRO(n) \
template<BOOST_PP_ENUM_PARAMS(n, class P)> \
- void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
+ void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
{ \
T* back_pos = containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size; \
if (this->members_.m_size < this->members_.m_capacity){ \
new((void*)(back_pos))value_type \
- (BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ (BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
++this->members_.m_size; \
} \
else{ \
- containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
+ containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
<value_type, T*, BOOST_PP_ENUM_PARAMS(n, P)> \
- proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
priv_range_insert(back_pos, 1, proxy); \
} \
} \
\
template<BOOST_PP_ENUM_PARAMS(n, class P)> \
- iterator emplace(const_iterator pos, BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
+ iterator emplace(const_iterator pos, BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_LIST, _)) \
{ \
size_type pos_n = pos - cbegin(); \
- containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
+ containers_detail::BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg) \
<value_type, T*, BOOST_PP_ENUM_PARAMS(n, P)> \
- proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
- priv_range_insert(containers_detail::get_pointer(pos.get_ptr()), 1, proxy); \
+ proxy(BOOST_PP_ENUM(n, BOOST_CONTAINERS_PP_PARAM_FORWARD, _)); \
+ priv_range_insert(containers_detail::get_pointer(pos.get_ptr()), 1, proxy); \
return iterator(this->members_.m_start + pos_n); \
} \
//!
@@ -1026,6 +1050,7 @@
}
}
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
//! <b>Requires</b>: position must be a valid iterator of *this.
//!
//! <b>Effects</b>: Insert a copy of x before position.
@@ -1034,16 +1059,7 @@
//!
//! <b>Complexity</b>: If position is end(), amortized constant time
//! Linear time otherwise.
- iterator insert(const_iterator position, insert_const_ref_type x)
- { return this->priv_insert(position, x); }
-
- #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
- iterator insert(const_iterator position, T &x) { return this->insert(position, const_cast<const T &>(x)); }
-
- template<class U>
- iterator insert(const_iterator position, const U &u, typename containers_detail::enable_if_c<containers_detail::is_same<T, U>::value && !::BOOST_CONTAINER_MOVE_NAMESPACE::is_movable<U>::value >::type* =0)
- { return this->priv_insert(position, u); }
- #endif
+ iterator insert(const_iterator position, const T &x);
//! <b>Requires</b>: position must be a valid iterator of *this.
//!
@@ -1053,15 +1069,10 @@
//!
//! <b>Complexity</b>: If position is end(), amortized constant time
//! Linear time otherwise.
- iterator insert(const_iterator position, BOOST_MOVE_MACRO_RV_REF(T) x)
- {
- //Just call more general insert(pos, size, value) and return iterator
- size_type pos_n = position - cbegin();
- this->insert(position
- ,repeat_move_it(repeat_it(x, 1))
- ,repeat_move_it(repeat_it()));
- return iterator(this->members_.m_start + pos_n);
- }
+ iterator insert(const_iterator position, T &&x);
+ #else
+ BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator)
+ #endif
//! <b>Requires</b>: pos must be a valid iterator of *this.
//!
@@ -1075,7 +1086,7 @@
void insert(const_iterator pos, InIt first, InIt last)
{
//Dispatch depending on integer/iterator
- const bool aux_boolean = containers_detail::is_convertible<InIt, std::size_t>::value;
+ const bool aux_boolean = containers_detail::is_convertible<InIt, size_type>::value;
typedef containers_detail::bool_<aux_boolean> Result;
this->priv_insert_dispatch(pos, first, last, Result());
}
@@ -1112,7 +1123,7 @@
{
T *pos = containers_detail::get_pointer(position.get_ptr());
T *beg = containers_detail::get_pointer(this->members_.m_start);
- BOOST_CONTAINER_MOVE_NAMESPACE::move(pos + 1, beg + this->members_.m_size, pos);
+ ::boost::move(pos + 1, beg + this->members_.m_size, pos);
--this->members_.m_size;
//Destroy last element
base_t::destroy(containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size);
@@ -1128,7 +1139,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_CONTAINER_MOVE_NAMESPACE::move
+ T* ptr = containers_detail::get_pointer(boost::move
(containers_detail::get_pointer(last.get_ptr())
,end_pos
,containers_detail::get_pointer(first.get_ptr())
@@ -1207,15 +1218,26 @@
return iterator(this->members_.m_start + pos_n);
}
- void priv_push_back(const T &x)
+ iterator priv_insert(const_iterator position, BOOST_RV_REF(T) x)
+ {
+ //Just call more general insert(pos, size, value) and return iterator
+ size_type pos_n = position - cbegin();
+ this->insert(position
+ ,repeat_move_it(repeat_it(x, 1))
+ ,repeat_move_it(repeat_it()));
+ return iterator(this->members_.m_start + pos_n);
+ }
+
+ template <class U>
+ void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x)
{
if (this->members_.m_size < this->members_.m_capacity){
//There is more memory, just construct a new object at the end
- new((void*)(containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size))value_type(x);
+ new((void*)containers_detail::get_pointer(this->members_.m_start + this->members_.m_size))value_type(::boost::forward<U>(x));
++this->members_.m_size;
}
else{
- this->insert(this->cend(), x);
+ this->insert(this->cend(), ::boost::forward<U>(x));
}
}
@@ -1335,10 +1357,10 @@
if (elems_after > n){
//New elements can be just copied.
//Move to uninitialized memory last objects
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_finish - n, old_finish, old_finish);
+ ::boost::uninitialized_move(old_finish - n, old_finish, old_finish);
this->members_.m_size += n;
//Copy previous to last objects to the initialized end
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, old_finish - n, old_finish);
+ boost::move_backward(pos, old_finish - n, old_finish);
//Insert new objects in the pos
interf.copy_all_to(pos);
}
@@ -1348,7 +1370,7 @@
interf.uninitialized_copy_some_and_update(old_finish, elems_after, false);
this->members_.m_size += n - elems_after;
//Copy old [pos, end()) elements to the uninitialized memory
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ ::boost::uninitialized_move
( pos, old_finish, containers_detail::get_pointer(this->members_.m_start) + this->members_.m_size);
this->members_.m_size += elems_after;
//Copy first new elements in pos
@@ -1370,7 +1392,7 @@
//the start of the new buffer
T *old_buffer = containers_detail::get_pointer(this->members_.m_start);
if(old_buffer){
- new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ new_finish = ::boost::uninitialized_move
(containers_detail::get_pointer(this->members_.m_start), pos, old_finish = new_finish);
constructed_values_destroyer.increment_size(new_finish - old_finish);
}
@@ -1381,7 +1403,7 @@
//Initialize from the rest of the old buffer,
//starting from previous point
if(old_buffer){
- new_finish = ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ new_finish = ::boost::uninitialized_move
(pos, old_buffer + this->members_.m_size, new_finish);
//Destroy and deallocate old elements
//If there is allocated memory, destroy and deallocate
@@ -1422,7 +1444,7 @@
//Check if s_before is big enough to hold the beginning of old data + new data
if(difference_type(s_before) >= difference_type(elemsbefore + n)){
//Copy first old values before pos, after that the new objects
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
this->members_.m_size = elemsbefore;
interf.uninitialized_copy_all_to(new_start + elemsbefore);
this->members_.m_size += n;
@@ -1440,7 +1462,7 @@
//|___________|__________|_________|________________________|
//
//Now initialize the rest of memory with the last old values
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move
+ ::boost::uninitialized_move
(pos, old_finish, new_start + elemsbefore + n);
//All new elements correctly constructed, avoid new element destruction
this->members_.m_size = old_size + n;
@@ -1467,13 +1489,13 @@
size_type raw_gap = s_before - (elemsbefore + n);
//Now initialize the rest of s_before memory with the
//first of elements after new values
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, pos + raw_gap, new_start + elemsbefore + n);
+ ::boost::uninitialized_move(pos, pos + raw_gap, new_start + elemsbefore + n);
//Update size since we have a contiguous buffer
this->members_.m_size = old_size + s_before;
//All new elements correctly constructed, avoid old element destruction
old_values_destroyer.release();
//Now copy remaining last objects in the old buffer begin
- T *to_destroy = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos + raw_gap, old_finish, old_start);
+ T *to_destroy = ::boost::move(pos + raw_gap, old_finish, old_start);
//Now destroy redundant elements except if they were moved and
//they have trivial destructor after move
size_type n_destroy = old_finish - to_destroy;
@@ -1532,13 +1554,13 @@
//
//Copy the first part of old_begin to raw_mem
T *start_n = old_start + difference_type(s_before);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, start_n, new_start);
+ ::boost::uninitialized_move(old_start, start_n, new_start);
//The buffer is all constructed until old_end,
//release destroyer and update size
old_values_destroyer.release();
this->members_.m_size = old_size + s_before;
//Now copy the second part of old_begin overwriting himself
- T* next = BOOST_CONTAINER_MOVE_NAMESPACE::move(start_n, pos, old_start);
+ T* next = ::boost::move(start_n, pos, old_start);
if(do_after){
//Now copy the new_beg elements
interf.copy_some_and_update(next, s_before, true);
@@ -1548,7 +1570,7 @@
interf.copy_all_to(next);
T* move_start = next + n;
//Now displace old_end elements
- T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos, old_finish, move_start);
+ T* move_end = ::boost::move(pos, old_finish, move_start);
//Destroy remaining moved elements from old_end except if
//they have trivial destructor after being moved
difference_type n_destroy = s_before - n;
@@ -1584,7 +1606,7 @@
//|___________|_____|_________|__________________________|
//
//First copy whole old_begin and part of new to raw_mem
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(old_start, pos, new_start);
+ ::boost::uninitialized_move(old_start, pos, new_start);
this->members_.m_size = elemsbefore;
const size_type mid_n = difference_type(s_before) - elemsbefore;
@@ -1603,7 +1625,7 @@
interf.copy_all_to(old_start);
T* move_start = old_start + (n-mid_n);
//Displace old_end
- T* move_end = BOOST_CONTAINER_MOVE_NAMESPACE::move(pos, old_finish, move_start);
+ T* move_end = ::boost::move(pos, old_finish, move_start);
//Destroy remaining moved elements from old_end except if they
//have trivial destructor after being moved
difference_type n_destroy = s_before - n;
@@ -1654,10 +1676,10 @@
//
//First copy the part of old_end raw_mem
T* finish_n = old_finish - difference_type(n_after);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(finish_n, old_finish, old_finish);
+ ::boost::uninitialized_move(finish_n, old_finish, old_finish);
this->members_.m_size += n_after;
//Displace the rest of old_end to the new position
- BOOST_CONTAINER_MOVE_NAMESPACE::move_backward(pos, finish_n, old_finish);
+ boost::move_backward(pos, finish_n, old_finish);
//Now overwrite with new_end
//The new_end part is [first + (n - n_after), last)
interf.copy_all_to(pos);
@@ -1680,7 +1702,7 @@
//The new_end part is [first + (n - n_after), last)
interf.uninitialized_copy_some_and_update(old_finish, elemsafter, false);
this->members_.m_size += mid_last_dist;
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_move(pos, old_finish, old_finish + mid_last_dist);
+ ::boost::uninitialized_move(pos, old_finish, old_finish + mid_last_dist);
this->members_.m_size += n_after - mid_last_dist;
//Now copy the part of new_end over constructed elements
interf.copy_all_to(pos);
@@ -1693,7 +1715,7 @@
void priv_range_insert(const_iterator pos, InIt first, InIt last, std::input_iterator_tag)
{
for(;first != last; ++first){
- this->insert(pos, BOOST_CONTAINER_MOVE_NAMESPACE::move(value_type(*first)));
+ this->insert(pos, ::boost::move(value_type(*first)));
}
}
@@ -1764,14 +1786,14 @@
T *end = std::copy(first, mid, start);
//Initialize the remaining new elements in the uninitialized memory
// iG std::uninitialized_copy(mid, last, end);
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(mid, last, end);
+ ::boost::uninitialized_copy_or_move(mid, last, end);
this->members_.m_size = n;
}
}
else if(!ret.second){
typename value_traits::UCopiedArrayDeallocator scoped_alloc(ret.first, this->alloc(), real_cap);
// iG std::uninitialized_copy(first, last, containers_detail::get_pointer(ret.first));
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, last, containers_detail::get_pointer(ret.first));
+ ::boost::uninitialized_copy_or_move(first, last, containers_detail::get_pointer(ret.first));
scoped_alloc.release();
//Destroy and deallocate old buffer
if(this->members_.m_start != 0){
@@ -1801,7 +1823,7 @@
FwdIt mid = first;
std::advance(mid, first_count);
// iG std::uninitialized_copy(first, mid, containers_detail::get_pointer(ret.first));
- ::BOOST_CONTAINER_MOVE_NAMESPACE::uninitialized_copy_or_move(first, mid, containers_detail::get_pointer(ret.first));
+ ::boost::uninitialized_copy_or_move(first, mid, containers_detail::get_pointer(ret.first));
if(old_offset > n){
//All old elements will be destroyed by "old_values_destroyer"
Modified: trunk/boost/interprocess/detail/file_wrapper.hpp
==============================================================================
--- trunk/boost/interprocess/detail/file_wrapper.hpp (original)
+++ trunk/boost/interprocess/detail/file_wrapper.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -25,7 +25,7 @@
class file_wrapper
{
/// @cond
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(file_wrapper)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(file_wrapper)
/// @endcond
public:
@@ -52,14 +52,14 @@
//!Moves the ownership of "moved"'s file to *this.
//!After the call, "moved" does not represent any file.
//!Does not throw
- file_wrapper(BOOST_INTERPROCESS_RV_REF(file_wrapper) moved)
+ file_wrapper(BOOST_RV_REF(file_wrapper) moved)
: m_handle(file_handle_t(detail::invalid_file()))
{ this->swap(moved); }
//!Moves the ownership of "moved"'s file to *this.
//!After the call, "moved" does not represent any file.
//!Does not throw
- file_wrapper &operator=(BOOST_INTERPROCESS_RV_REF(file_wrapper) moved)
+ file_wrapper &operator=(BOOST_RV_REF(file_wrapper) moved)
{
file_wrapper tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/detail/in_place_interface.hpp
==============================================================================
--- trunk/boost/interprocess/detail/in_place_interface.hpp (original)
+++ trunk/boost/interprocess/detail/in_place_interface.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -18,6 +18,7 @@
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/type_traits/alignment_of.hpp>
#include <typeinfo> //typeid
//!\file
@@ -46,7 +47,7 @@
struct placement_destroy : public in_place_interface
{
placement_destroy()
- : in_place_interface(detail::alignment_of<T>::value, sizeof(T), typeid(T).name())
+ : in_place_interface(::boost::alignment_of<T>::value, sizeof(T), typeid(T).name())
{}
virtual void destroy_n(void *mem, std::size_t num, std::size_t &destroyed)
Modified: trunk/boost/interprocess/detail/intermodule_singleton.hpp
==============================================================================
--- trunk/boost/interprocess/detail/intermodule_singleton.hpp (original)
+++ trunk/boost/interprocess/detail/intermodule_singleton.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -27,6 +27,7 @@
#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
#include <boost/interprocess/detail/os_file_functions.hpp>
#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
#include <boost/assert.hpp>
#include <cstddef>
#include <cstdio>
@@ -636,7 +637,7 @@
return *static_cast<ManagedShMem *>(static_cast<void *>(&shm_mem));
}
- enum { MemSize = ((sizeof(ManagedShMem)-1)/sizeof(max_align))+1u };
+ enum { MemSize = ((sizeof(ManagedShMem)-1)/sizeof(::boost::detail::max_align))+1u };
static void initialize_shm();
static void destroy_shm();
@@ -645,7 +646,7 @@
static volatile boost::uint32_t this_module_singleton_count;
//this_module_shm_initialized is the state of this module's shm class object
static volatile boost::uint32_t this_module_shm_initialized;
- static max_align shm_mem[MemSize];
+ static ::boost::detail::max_align shm_mem[MemSize];
};
template<class ManagedShMem>
@@ -655,7 +656,7 @@
volatile boost::uint32_t intermodule_singleton_common<ManagedShMem>::this_module_shm_initialized;
template<class ManagedShMem>
-max_align intermodule_singleton_common<ManagedShMem>::shm_mem[intermodule_singleton_common<ManagedShMem>::MemSize];
+::boost::detail::max_align intermodule_singleton_common<ManagedShMem>::shm_mem[intermodule_singleton_common<ManagedShMem>::MemSize];
template<class ManagedShMem>
void intermodule_singleton_common<ManagedShMem>::initialize_shm()
Modified: trunk/boost/interprocess/detail/intersegment_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/detail/intersegment_ptr.hpp (original)
+++ trunk/boost/interprocess/detail/intersegment_ptr.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -97,7 +97,7 @@
std::size_t pow : pow_size_bits;
std::size_t frc : frc_size_bits;
std::size_t beg : begin_bits;
- std::ptrdiff_t off : sizeof(ptrdiff_t)*CHAR_BIT - 2;
+ std::ptrdiff_t off : sizeof(std::ptrdiff_t)*CHAR_BIT - 2;
std::ptrdiff_t bits : 2;
};
@@ -159,7 +159,7 @@
std::size_t diff = orig_size - low_size;
BOOST_ASSERT(pow >= frc_size_bits);
std::size_t rounded = detail::get_rounded_size_po2
- (diff, (1u << (pow - frc_size_bits)));
+ (diff, (std::size_t)(1u << (pow - frc_size_bits)));
if(rounded == low_size){
++pow;
frc = 0;
@@ -762,7 +762,7 @@
//!This only works with two basic_intersegment_ptr pointing
//!to the same segment. Otherwise undefined
template <class T2>
- ptrdiff_t _diff(const intersegment_ptr<T2> &other) const
+ std::ptrdiff_t _diff(const intersegment_ptr<T2> &other) const
{ return base_t::diff(other); }
//!Returns true if both point to the
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -86,7 +86,9 @@
typedef MemoryAlgorithm memory_algorithm;
typedef typename MemoryAlgorithm::mutex_family mutex_family;
typedef CharType char_t;
- typedef std::ptrdiff_t handle_t;
+ typedef typename MemoryAlgorithm::size_type size_type;
+ typedef typename MemoryAlgorithm::difference_type difference_type;
+ typedef difference_type handle_t;
typedef typename segment_manager::
const_named_iterator const_named_iterator;
typedef typename segment_manager::
@@ -102,14 +104,14 @@
/// @endcond
- static const std::size_t PayloadPerAllocation = segment_manager::PayloadPerAllocation;
+ static const size_type PayloadPerAllocation = segment_manager::PayloadPerAllocation;
private:
typedef basic_managed_memory_impl
<CharType, MemoryAlgorithm, IndexType, Offset> self_t;
protected:
template<class ManagedMemory>
- static bool grow(const char *filename, std::size_t extra_bytes)
+ static bool grow(const char *filename, size_type extra_bytes)
{
typedef typename ManagedMemory::device_type device_type;
//Increase file size
@@ -135,7 +137,7 @@
static bool shrink_to_fit(const char *filename)
{
typedef typename ManagedMemory::device_type device_type;
- std::size_t new_size, old_size;
+ size_type new_size, old_size;
try{
ManagedMemory managed_memory(open_only, filename);
old_size = managed_memory.get_size();
@@ -163,7 +165,7 @@
{ this->close_impl(); }
//!Places segment manager in the reserved space. This can throw.
- bool create_impl (void *addr, std::size_t size)
+ bool create_impl (void *addr, size_type size)
{
if(mp_header) return false;
@@ -185,7 +187,7 @@
}
//!Connects to a segment manager in the reserved buffer. Never throws.
- bool open_impl (void *addr, std::size_t)
+ bool open_impl (void *addr, size_type)
{
if(mp_header) return false;
mp_header = static_cast<segment_manager*>(addr);
@@ -211,7 +213,7 @@
}
//!
- void grow(std::size_t extra_bytes)
+ void grow(size_type extra_bytes)
{ mp_header->grow(extra_bytes); }
void shrink_to_fit()
@@ -228,12 +230,12 @@
{ return reinterpret_cast<char*>(mp_header) - Offset; }
//!Returns the size of memory segment. Never throws.
- std::size_t get_size () const
+ size_type get_size () const
{ return mp_header->get_size() + Offset; }
//!Returns the number of free bytes of the memory
//!segment
- std::size_t get_free_memory() const
+ size_type get_free_memory() const
{ return mp_header->get_free_memory(); }
//!Returns the result of "all_memory_deallocated()" function
@@ -255,8 +257,8 @@
//!The address must belong to the memory segment. Never throws.
handle_t get_handle_from_address (const void *ptr) const
{
- return reinterpret_cast<const char*>(ptr) -
- reinterpret_cast<const char*>(this->get_address());
+ return (handle_t)(reinterpret_cast<const char*>(ptr) -
+ reinterpret_cast<const char*>(this->get_address()));
}
//!Returns true if the address belongs to the managed memory segment
@@ -274,25 +276,25 @@
//!Searches for nbytes of free memory in the segment, marks the
//!memory as used and return the pointer to the memory. If no
//!memory is available throws a boost::interprocess::bad_alloc exception
- void* allocate (std::size_t nbytes)
+ void* allocate (size_type nbytes)
{ return mp_header->allocate(nbytes); }
//!Searches for nbytes of free memory in the segment, marks the
//!memory as used and return the pointer to the memory. If no memory
//!is available returns 0. Never throws.
- void* allocate (std::size_t nbytes, std::nothrow_t nothrow)
+ void* allocate (size_type nbytes, std::nothrow_t nothrow)
{ return mp_header->allocate(nbytes, nothrow); }
//!Allocates nbytes bytes aligned to "alignment" bytes. "alignment"
//!must be power of two. If no memory
//!is available returns 0. Never throws.
- void * allocate_aligned (std::size_t nbytes, std::size_t alignment, std::nothrow_t nothrow)
+ void * allocate_aligned (size_type nbytes, size_type alignment, std::nothrow_t nothrow)
{ return mp_header->allocate_aligned(nbytes, alignment, nothrow); }
template<class T>
std::pair<T *, bool>
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr = 0)
{
return mp_header->allocation_command
@@ -302,7 +304,7 @@
//!Allocates nbytes bytes aligned to "alignment" bytes. "alignment"
//!must be power of two. If no
//!memory is available throws a boost::interprocess::bad_alloc exception
- void * allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ void * allocate_aligned(size_type nbytes, size_type alignment)
{ return mp_header->allocate_aligned(nbytes, alignment); }
/// @cond
@@ -310,19 +312,19 @@
//Experimental. Don't use.
//!Allocates n_elements of elem_size bytes.
- multiallocation_chain allocate_many(std::size_t elem_bytes, std::size_t num_elements)
+ multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
{ return mp_header->allocate_many(elem_bytes, num_elements); }
//!Allocates n_elements, each one of elem_sizes[i] bytes.
- multiallocation_chain allocate_many(const std::size_t *elem_sizes, std::size_t n_elements)
+ multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements)
{ return mp_header->allocate_many(elem_sizes, n_elements); }
//!Allocates n_elements of elem_size bytes.
- multiallocation_chain allocate_many(std::size_t elem_bytes, std::size_t num_elements, std::nothrow_t nothrow)
+ multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements, std::nothrow_t nothrow)
{ return mp_header->allocate_many(elem_bytes, num_elements, nothrow); }
//!Allocates n_elements, each one of elem_sizes[i] bytes.
- multiallocation_chain allocate_many(const std::size_t *elem_sizes, std::size_t n_elements, std::nothrow_t nothrow)
+ multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, std::nothrow_t nothrow)
{ return mp_header->allocate_many(elem_sizes, n_elements, nothrow); }
//!Allocates n_elements, each one of elem_sizes[i] bytes.
@@ -339,7 +341,7 @@
//!buffer and the object count. If not found returned pointer is 0.
//!Never throws.
template <class T>
- std::pair<T*, std::size_t> find (char_ptr_holder_t name)
+ std::pair<T*, size_type> find (char_ptr_holder_t name)
{ return mp_header->template find<T>(name); }
//!Creates a named object or array in memory
@@ -619,19 +621,19 @@
//!Returns the length of an object created with construct/find_or_construct
//!functions (1 if is a single element, >=1 if it's an array). Does not throw.
template<class T>
- static std::size_t get_instance_length(const T *ptr)
+ static size_type get_instance_length(const T *ptr)
{ return segment_manager::get_instance_length(ptr); }
//!Preallocates needed index resources to optimize the
//!creation of "num" named objects in the memory segment.
//!Can throw boost::interprocess::bad_alloc if there is no enough memory.
- void reserve_named_objects(std::size_t num)
+ void reserve_named_objects(size_type num)
{ mp_header->reserve_named_objects(num); }
//!Preallocates needed index resources to optimize the
//!creation of "num" unique objects in the memory segment.
//!Can throw boost::interprocess::bad_alloc if there is no enough memory.
- void reserve_unique_objects(std::size_t num)
+ void reserve_unique_objects(size_type num)
{ mp_header->reserve_unique_objects(num); }
//!Calls shrink_to_fit in both named and unique object indexes
@@ -641,12 +643,12 @@
//!Returns the number of named objects stored
//!in the managed segment.
- std::size_t get_num_named_objects()
+ size_type get_num_named_objects()
{ return mp_header->get_num_named_objects(); }
//!Returns the number of unique objects stored
//!in the managed segment.
- std::size_t get_num_unique_objects()
+ size_type get_num_unique_objects()
{ return mp_header->get_num_unique_objects(); }
//!Returns a constant iterator to the index storing the
@@ -704,7 +706,7 @@
//!buffer and the object count. If not found returned pointer is 0.
//!Never throws.
template <class T>
- std::pair<T*, std::size_t> find_no_lock (char_ptr_holder_t name)
+ std::pair<T*, size_type> find_no_lock (char_ptr_holder_t name)
{ return mp_header->template find_no_lock<T>(name); }
/// @endcond
@@ -725,7 +727,7 @@
create_open_func(BasicManagedMemoryImpl * const frontend, detail::create_enum_t type)
: m_frontend(frontend), m_type(type){}
- bool operator()(void *addr, std::size_t size, bool created) const
+ bool operator()(void *addr, typename BasicManagedMemoryImpl::size_type size, bool created) const
{
if(((m_type == detail::DoOpen) && created) ||
((m_type == detail::DoCreate) && !created))
Modified: trunk/boost/interprocess/detail/managed_multi_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/detail/managed_multi_shared_memory.hpp (original)
+++ trunk/boost/interprocess/detail/managed_multi_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -63,10 +63,15 @@
typedef basic_managed_multi_shared_memory
<CharType, MemoryAlgorithm, IndexType> self_t;
+ typedef detail::basic_managed_memory_impl
+ <CharType, MemoryAlgorithm, IndexType> base_t;
+
typedef typename MemoryAlgorithm::void_pointer void_pointer;
typedef typename detail::
managed_open_or_create_impl<shared_memory_object> managed_impl;
typedef typename void_pointer::segment_group_id segment_group_id;
+ typedef typename base_t::size_type size_type;
+
////////////////////////////////////////////////////////////////////////
//
// Some internal helper structs/functors
@@ -86,7 +91,7 @@
// const void *addr)
// : m_shmem(shmem), m_mem_name(mem_name), m_addr(addr){}
//
-// void *operator()(std::size_t size)
+// void *operator()(size_type size)
// {
// if(!m_shmem.create(m_mem_name, size, m_addr))
// return 0;
@@ -102,7 +107,7 @@
: public multi_segment_services
{
public:
- typedef std::pair<void *, std::size_t> result_type;
+ typedef std::pair<void *, size_type> result_type;
typedef basic_managed_multi_shared_memory frontend_t;
typedef typename
basic_managed_multi_shared_memory::void_pointer void_pointer;
@@ -110,7 +115,7 @@
group_services(frontend_t *const frontend)
: mp_frontend(frontend), m_group(0), m_min_segment_size(0){}
- virtual std::pair<void *, std::size_t> create_new_segment(std::size_t alloc_size)
+ virtual std::pair<void *, size_type> create_new_segment(size_type alloc_size)
{
//We should allocate an extra byte so that the
//[base_addr + alloc_size] byte belongs to this segment
@@ -138,17 +143,17 @@
segment_group_id get_group() const
{ return m_group; }
- void set_min_segment_size(std::size_t min_segment_size)
+ void set_min_segment_size(size_type min_segment_size)
{ m_min_segment_size = min_segment_size; }
- std::size_t get_min_segment_size() const
+ size_type get_min_segment_size() const
{ return m_min_segment_size; }
private:
frontend_t * const mp_frontend;
segment_group_id m_group;
- std::size_t m_min_segment_size;
+ size_type m_min_segment_size;
};
//!Functor to execute atomically when opening or creating a shared memory
@@ -160,10 +165,10 @@
basic_managed_multi_shared_memory::void_pointer void_pointer;
create_open_func(self_t * const frontend,
- type_t type, std::size_t segment_number)
+ type_t type, size_type segment_number)
: mp_frontend(frontend), m_type(type), m_segment_number(segment_number){}
- bool operator()(void *addr, std::size_t size, bool created) const
+ bool operator()(void *addr, size_type size, bool created) const
{
if(((m_type == DoOpen) && created) ||
((m_type == DoCreate) && !created))
@@ -203,7 +208,7 @@
}
self_t * const mp_frontend;
type_t m_type;
- std::size_t m_segment_number;
+ size_type m_segment_number;
};
//!Functor to execute atomically when closing a shared memory segment.
@@ -223,9 +228,6 @@
self_t * const mp_frontend;
};
- typedef detail::basic_managed_memory_impl
- <CharType, MemoryAlgorithm, IndexType> base_t;
-
//Friend declarations
friend struct basic_managed_multi_shared_memory::create_open_func;
friend struct basic_managed_multi_shared_memory::close_func;
@@ -240,7 +242,7 @@
basic_managed_multi_shared_memory(create_only_t,
const char *name,
- std::size_t size,
+ size_type size,
const permissions &perm = permissions())
: m_group_services(get_this_pointer())
{
@@ -249,7 +251,7 @@
basic_managed_multi_shared_memory(open_or_create_t,
const char *name,
- std::size_t size,
+ size_type size,
const permissions &perm = permissions())
: m_group_services(get_this_pointer())
{
@@ -268,7 +270,7 @@
private:
bool priv_open_or_create(typename create_open_func::type_t type,
const char *name,
- std::size_t size,
+ size_type size,
const permissions &perm)
{
if(!m_shmem_list.empty())
@@ -298,17 +300,17 @@
}
bool priv_new_segment(typename create_open_func::type_t type,
- std::size_t size,
+ size_type size,
const void *addr,
const permissions &perm)
{
BOOST_TRY{
//Get the number of groups of this multi_segment group
- std::size_t segment_id = m_shmem_list.size();
+ size_type segment_id = m_shmem_list.size();
//Format the name of the shared memory: append segment number.
boost::interprocess::basic_ovectorstream<boost::interprocess::string> formatter;
//Pre-reserve string size
- std::size_t str_size = m_root_name.length()+10;
+ size_type str_size = m_root_name.length()+10;
if(formatter.vector().size() < str_size){
//This can throw.
formatter.reserve(str_size);
Modified: trunk/boost/interprocess/detail/managed_open_or_create_impl.hpp
==============================================================================
--- trunk/boost/interprocess/detail/managed_open_or_create_impl.hpp (original)
+++ trunk/boost/interprocess/detail/managed_open_or_create_impl.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -23,6 +23,8 @@
#include <boost/interprocess/detail/mpl.hpp>
#include <boost/interprocess/detail/move.hpp>
#include <boost/interprocess/permissions.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
#include <boost/cstdint.hpp>
namespace boost {
@@ -86,7 +88,7 @@
: public managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction>
{
//Non-copyable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(managed_open_or_create_impl)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(managed_open_or_create_impl)
typedef typename managed_open_or_create_impl_device_id_t<DeviceAbstraction>::type device_id_t;
typedef managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction> DevHolder;
@@ -103,7 +105,7 @@
ManagedOpenOrCreateUserOffset =
detail::ct_rounded_size
< sizeof(boost::uint32_t)
- , detail::alignment_of<detail::max_align>::value>::value;
+ , ::boost::alignment_of< ::boost::detail::max_align >::value >::value;
managed_open_or_create_impl()
{}
@@ -213,10 +215,10 @@
, construct_func);
}
- managed_open_or_create_impl(BOOST_INTERPROCESS_RV_REF(managed_open_or_create_impl) moved)
+ managed_open_or_create_impl(BOOST_RV_REF(managed_open_or_create_impl) moved)
{ this->swap(moved); }
- managed_open_or_create_impl &operator=(BOOST_INTERPROCESS_RV_REF(managed_open_or_create_impl) moved)
+ managed_open_or_create_impl &operator=(BOOST_RV_REF(managed_open_or_create_impl) moved)
{
managed_open_or_create_impl tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/detail/move.hpp
==============================================================================
--- trunk/boost/interprocess/detail/move.hpp (original)
+++ trunk/boost/interprocess/detail/move.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -1,7 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright David Abrahams, Vicente Botet 2009.
-// (C) Copyright Ion Gaztanaga 2009-2010.
+// (C) Copyright Ion Gaztanaga 2010-2011.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -12,1146 +11,18 @@
//! \file
-#ifndef BOOST_MOVE_DETAIL_MOVE_HPP
-#define BOOST_MOVE_DETAIL_MOVE_HPP
+#ifndef BOOST_INTERPROCESS_DETAIL_MOVE_HPP
+#define BOOST_INTERPROCESS_DETAIL_MOVE_HPP
-#include <boost/config.hpp>
-#include <algorithm> //copy, copy_backward
-#include <memory> //uninitialized_copy
-#include <iterator> //std::iterator
-#include <boost/mpl/if.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/utility/addressof.hpp>
-
-//! Defining or undefining this macro will change Boost.Move behaviour
-//! for copyable and movable classes when assigning from non-const rvalues:
-//! \code
-//! copyable_and_movable produce(){ return copyable_and_movable(); }
-//! \endcode
-//! If the macro is NOT defined:
-//! \code
-//! copyable_and_movable cm;
-//! cm = copyable_and_movable(); //object is COPIED (missed optimization)
-//! \endcode
-//! If the macro IS defined:
-//! \code
-//! copyable_and_movable cm;
-//! cm = copyable_and_movable(); //object is MOVED
-//! \endcode
-//! However, the second option has also some downsides. See documentation for more details.
-#define BOOST_MOVE_OPTIMIZED_EMULATION
-
-/// @cond
-
-//Define to easily port between Boost.Move and internal Boost.Interprocess move emulation
-//
-// This configuration is temporary. Boost.Interprocess emulation uses
-// different macros to avoid any redefinition of a top-levl Boost macro.
-// It will disappear once the library is accepted and
-// Boost.Interprocess is updated to the standard interface.
-//
-#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 {
-INTERPROCESS_NAMESPACE_BEGIN
-namespace move_detail {
-
-template <class T>
-struct identity
-{
- typedef T type;
-};
-
-template <class T, class U>
-class is_convertible
-{
- typedef char true_t;
- class false_t { char dummy[2]; };
- static true_t dispatch(U);
- static false_t dispatch(...);
- static T trigger();
- public:
- enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
-};
-
-} //namespace move_detail {
-INTERPROCESS_NAMESPACE_END
-} //namespace boost {
-
-/// @endcond
-
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
-
-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5)
-
-#define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-
-#else
-
-#if defined(_MSC_VER) && (_MSC_VER == 1600)
-#define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
-#endif
-
-#endif
-
-#endif
-
-
-#if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
-
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-#ifdef __GNUC__
-# define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
-#else
-# define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS
-#endif
-
-namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// struct rv
-//
-//////////////////////////////////////////////////////////////////////////////
-template <class T>
-class rv : public T
-{
- rv();
- ~rv();
- rv(rv const&);
- void operator=(rv const&);
-} BOOST_MOVE_ATTRIBUTE_MAY_ALIAS;
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_detail::is_rv
-//
-//////////////////////////////////////////////////////////////////////////////
-
-namespace move_detail {
-
-template <class T>
-struct is_rv
-{
- static const bool value = false;
-};
-
-template <class T>
-struct is_rv< rv<T> >
-{
- static const bool value = true;
-};
-
-} //namespace move_detail {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// is_movable
-//
-//////////////////////////////////////////////////////////////////////////////
-template<class T>
-struct is_movable
- : public ::boost::mpl::bool_<move_detail::is_convertible<T, rv<T>&>::value>
-{
-};
-
-template<class T>
-struct is_movable< rv<T> >
- : public ::boost::mpl::bool_<false>
-{
-};
-
-template <class T>
-struct has_nothrow_move
- : public ::boost::mpl::bool_<false>
-{
-};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move()
-//
-//////////////////////////////////////////////////////////////////////////////
-template <class T>
-typename ::boost::disable_if<is_movable<T>, T&>::type move(T& x)
-{
- return x;
-}
-
-template <class T>
-typename enable_if<is_movable<T>, rv<T>&>::type move(T& x)
-{
- return *static_cast<rv<T>* >(boost::addressof(x));
-}
-
-template <class T>
-typename enable_if<is_movable<T>, rv<T>&>::type move(rv<T>& x)
-{
- return x;
-}
-
-
-#define BOOST_RV_REF(TYPE)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
-//
-
-#define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
-//
-
-#define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
-//
-
-
-#define BOOST_FWD_REF(TYPE)\
- const TYPE & \
-//
-
-#define BOOST_CATCH_CONST_RLVALUE(TYPE)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
-//
-
-#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPY_ASSIGN_REF(TYPE)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE >& \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2> >& \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const ::BOOST_MOVE_NAMESPACE::rv< TYPE<ARG1, ARG2, ARG3> >& \
-//
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// forward()
-//
-//////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-typename enable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, T &>::type
- forward(const typename move_detail::identity<T>::type &x)
-{
- return const_cast<T&>(x);
-}
-
-template <class T>
-typename disable_if< ::BOOST_MOVE_NAMESPACE::move_detail::is_rv<T>, const T &>::type
- forward(const typename move_detail::identity<T>::type &x)
-{
- return x;
-}
-
-#else //BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPY_ASSIGN_REF(TYPE)\
- const TYPE & \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const TYPE< ARG1, ARG2 >& \
-//
-
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- const TYPE< ARG1, ARG2, ARG3 > & \
-//
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// forward()
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//Catches const lvalues for movable types
-template <class T>
-const T&
- forward( BOOST_CATCH_CONST_RLVALUE(T) x
- , typename ::boost::enable_if_c< ::BOOST_MOVE_NAMESPACE::is_movable<T>::value >::type* = 0)
-{
- return static_cast<const T&>(x);
-}
-
-//Catches const lvalues for non-movable types
-template <class T>
-const T&
- forward( const T &x
- , typename ::boost::enable_if_c< !::BOOST_MOVE_NAMESPACE::is_movable<T>::value &&
- !::boost::move_detail::is_rv<T>::value
- >::type* = 0)
-{
- return static_cast<const T&>(x);
-}
-
-//Catches forwarded ::boost::rv<T> via BOOST_FWD_REFs
-template <class T>
-T &
- forward( const T &t
- , typename ::boost::enable_if_c< ::boost::move_detail::is_rv<T>::value >::type* = 0)
-{
- return const_cast<T&>(t);
-}
-
-//Catches forwarded ::boost::rv<T>
-template <class T, class U>
-const T &
- forward( const U &u
- , typename ::boost::enable_if_c< ::boost::is_same< ::boost::rv<T>, U >::value >::type * = 0)
-{
- return static_cast<const T&>(u);
-}
-
-//Catches non-const lvalues
-template <class T>
-T&
- forward( typename move_detail::identity<T>::type &x
- , typename ::boost::enable_if_c< !::boost::move_detail::is_rv<T>::value >::type* = 0)
-{
- return x;
-}
-
-//Catches non-const rvalues
-template <class T>
-typename enable_if<is_movable<T>, ::boost::rv<T> & >::type
- forward(BOOST_RV_REF(T) x)
-{ return x; }
-
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// BOOST_MOVABLE_BUT_NOT_COPYABLE
-//
-//////////////////////////////////////////////////////////////////////////////
-#define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
- private:\
- TYPE(TYPE &);\
- TYPE& operator=(TYPE &);\
- public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *static_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- private:\
-//
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// BOOST_COPYABLE_AND_MOVABLE
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
- public:\
- TYPE& operator=(TYPE &t)\
- { this->operator=(static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
- public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *static_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- private:\
-//
-
-#else //#ifdef BOOST_MOVE_OPTIMIZED_EMULATION
-
-#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
- public:\
- operator ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() \
- { return *static_cast< ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- operator const ::BOOST_MOVE_NAMESPACE::rv<TYPE>&() const \
- { return *static_cast<const ::BOOST_MOVE_NAMESPACE::rv<TYPE>* >(this); }\
- private:\
-//
-
-#endif
-
-
-INTERPROCESS_NAMESPACE_END
-} //namespace boost
-
-#else //BOOST_NO_RVALUE_REFERENCES
-
-#include <boost/type_traits/remove_reference.hpp>
-
-namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN
-
-/// @cond
-
-namespace move_detail {
-
-template<class T>
-struct is_lvalue_reference
- : public ::boost::mpl::bool_<false>
-{};
-
-template<class T>
-struct is_lvalue_reference<T&>
- : public ::boost::mpl::bool_<true>
-{};
-
-typedef char one;
-struct two {one _[2];};
-
-template <class T>
-struct internal_member_value_traits
-{
- template <class U> static one test(...);
- template <class U> static two test(typename U::boost_move_emulation_t* = 0);
- static const bool value = sizeof(test<T>(0)) == sizeof(two);
-};
-
-} //namespace move_detail {
-
-/// @endcond
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// is_movable
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! For compilers with rvalue references, this traits class returns true
-//! if BOOST_ENABLE_MOVE_EMULATION is activated.
-//!
-//! For other compilers returns true if T is convertible to <i>::boost::rv<T>&</i>
-template<class T>
-struct is_movable
- : public ::boost::mpl::bool_<move_detail::internal_member_value_traits<T>::value>
-{
-};
-
-//! By default this traits returns false. Classes with non-thworing move construction
-//! and assignment should specialize this trait to obtain some performance improvements.
-template <class T>
-struct has_nothrow_move
- : public ::boost::mpl::bool_<false>
-{};
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-#if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-//! This function provides a way to convert a reference into a rvalue reference
-//! in compilers with rvalue references. For other compilers converts T & into
-//! <i>::boost::rv<T> &</i> so that move emulation is activated.
-template <class T> inline
-rvalue_reference move (input_reference);
-
-#else //BOOST_MOVE_DOXYGEN_INVOKED
-
-#if defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
-
-//Old move approach, lvalues could bind to rvalue references
-template <class T> inline
-typename remove_reference<T>::type && move(T&& t)
-{ return t; }
-
-#else //Old move
-
-template <class T> inline
-typename remove_reference<T>::type && move(T&& t)
-{ return static_cast<typename remove_reference<T>::type &&>(t); }
-
-#endif //Old move
-
-#endif //BOOST_MOVE_DOXYGEN_INVOKED
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// forward
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-#if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-//! This function provides limited form of forwarding that is usually enough for
-//! in-place construction and avoids the exponential overloading necessary for
-//! perfect forwarding in C++03.
-//!
-//! For compilers with rvalue references this function provides perfect forwarding.
-//!
-//! Otherwise:
-//! * If input_reference binds to const ::boost::rv<T> & then it output_reference is
-//! ::boost::rev<T> &
-//!
-//! * Else, input_reference is equal to output_reference is equal to input_reference.
-template <class T> inline output_reference forward(input_reference);
-
-#else
-
-#if defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
-
-//Old move approach, lvalues could bind to rvalue references
-
-template <class T> inline
-T&& forward (typename move_detail::identity<T>::type&& t)
-{ return t; }
-
-#else //Old move
-
-//Implementation #5 from N2951, thanks to Howard Hinnant
-
-template <class T, class U>
-inline T&& forward(U&& t
- , typename enable_if_c<
- move_detail::is_lvalue_reference<T>::value ? move_detail::is_lvalue_reference<U>::value : true>::type * = 0/*
- , typename enable_if_c<
- move_detail::is_convertible
- <typename remove_reference<U>::type*, typename remove_reference<T>::type*>::value>::type * = 0*/)
-{ return static_cast<T&&>(t); }
-
-#endif //Old move
-
-#endif //BOOST_MOVE_DOXYGEN_INVOKED
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// BOOST_ENABLE_MOVE_EMULATION
-//
-//////////////////////////////////////////////////////////////////////////////
-
-///@cond
-
-#define BOOST_ENABLE_MOVE_EMULATION(TYPE)\
- typedef int boost_move_emulation_t;
-\
-//
-
-/// @endcond
-
-//! 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_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
- public:\
- typedef int boost_move_emulation_t;\
- private:\
- TYPE(const TYPE &);\
- TYPE& operator=(const TYPE &);\
-//
-
-//! 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)\
- typedef int boost_move_emulation_t;
-//
-
-/// @cond
-
-#define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- TYPE<ARG1, ARG2> && \
-//
-
-#define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- TYPE<ARG1, ARG2, ARG3> && \
-//
-
-/// @endcond
-
-//!This macro is used to achieve portable syntax in move
-//!constructors and assignments for classes marked as
-//!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE
-#define BOOST_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_COPY_ASSIGN_REF(TYPE)\
- const TYPE & \
-//
-
-/// @cond
-
-#define BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
- const TYPE<ARG1, ARG2> & \
-//
-
-#define BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
- TYPE<ARG1, ARG2, ARG3>& \
-//
-
-/// @endcond
-
-//! This macro is used to implement portable perfect forwarding
-//! as explained in the documentation.
-#define BOOST_FWD_REF(TYPE)\
- TYPE && \
-//
-
-/// @cond
-
-#define BOOST_CATCH_CONST_RLVALUE(TYPE)\
- const TYPE & \
-//
-
-/// @endcond
-
-INTERPROCESS_NAMESPACE_END
-} //namespace boost {
-
-#endif //BOOST_NO_RVALUE_REFERENCES
+#include <boost/move/move.hpp>
namespace boost {
-INTERPROCESS_NAMESPACE_BEGIN
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! Class template move_iterator is an iterator adaptor with the same behavior
-//! as the underlying iterator except that its dereference operator implicitly
-//! converts the value returned by the underlying iterator's dereference operator
-//! to an rvalue reference. Some generic algorithms can be called with move
-//! iterators to replace copying with moving.
-template <class It>
-class move_iterator
-{
- public:
- typedef It iterator_type;
- typedef typename std::iterator_traits<iterator_type>::value_type value_type;
- #if !defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
- typedef value_type && reference;
- #else
- typedef typename ::boost::mpl::if_
- < ::BOOST_MOVE_NAMESPACE::is_movable<value_type>
- , ::BOOST_MOVE_NAMESPACE::rv<value_type>&
- , value_type & >::type reference;
- #endif
- typedef It pointer;
- typedef typename std::iterator_traits<iterator_type>::difference_type difference_type;
- typedef typename std::iterator_traits<iterator_type>::iterator_category iterator_category;
-
- move_iterator()
- {}
-
- explicit move_iterator(It i)
- : m_it(i)
- {}
-
- template <class U>
- move_iterator(const move_iterator<U>& u)
- : m_it(u.base())
- {}
-
- iterator_type base() const
- { return m_it; }
-
- reference operator*() const
- {
- #if defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
- return *m_it;
- #else
- return ::BOOST_MOVE_NAMESPACE::move(*m_it);
- #endif
- }
-
- pointer operator->() const
- { return m_it; }
-
- move_iterator& operator++()
- { ++m_it; return *this; }
-
- move_iterator<iterator_type> operator++(int)
- { move_iterator<iterator_type> tmp(*this); ++(*this); return tmp; }
-
- move_iterator& operator--()
- { --m_it; return *this; }
-
- move_iterator<iterator_type> operator--(int)
- { move_iterator<iterator_type> tmp(*this); --(*this); return tmp; }
-
- move_iterator<iterator_type> operator+ (difference_type n) const
- { return move_iterator<iterator_type>(m_it + n); }
-
- move_iterator& operator+=(difference_type n)
- { m_it += n; return *this; }
-
- move_iterator<iterator_type> operator- (difference_type n) const
- { return move_iterator<iterator_type>(m_it - n); }
-
- move_iterator& operator-=(difference_type n)
- { m_it -= n; return *this; }
-
- reference operator[](difference_type n) const
- {
- #if defined(BOOST_NO_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
- return m_it[n];
- #else
- return ::BOOST_MOVE_NAMESPACE::move(m_it[n]);
- #endif
- }
-
- friend bool operator==(const move_iterator& x, const move_iterator& y)
- { return x.base() == y.base(); }
-
- friend bool operator!=(const move_iterator& x, const move_iterator& y)
- { return x.base() != y.base(); }
-
- friend bool operator< (const move_iterator& x, const move_iterator& y)
- { return x.base() < y.base(); }
-
- friend bool operator<=(const move_iterator& x, const move_iterator& y)
- { return x.base() <= y.base(); }
-
- friend bool operator> (const move_iterator& x, const move_iterator& y)
- { return x.base() > y.base(); }
-
- friend bool operator>=(const move_iterator& x, const move_iterator& y)
- { return x.base() >= y.base(); }
-
- friend difference_type operator-(const move_iterator& x, const move_iterator& y)
- { return x.base() - y.base(); }
-
- friend move_iterator operator+(difference_type n, const move_iterator& x)
- { return move_iterator(x.base() + n); }
-
- private:
- It m_it;
-};
-
-
-//is_move_iterator
-namespace move_detail {
-
-template <class I>
-struct is_move_iterator
- : public ::boost::mpl::bool_<false>
-{
-};
-
-template <class I>
-struct is_move_iterator< ::BOOST_MOVE_NAMESPACE::move_iterator<I> >
- : public ::boost::mpl::bool_<true>
-{
-};
-
-} //namespace move_detail {
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//!
-//! <b>Returns</b>: move_iterator<It>(i).
-template<class It>
-move_iterator<It> make_move_iterator(const It &it)
-{ return move_iterator<It>(it); }
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// back_move_insert_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-//! A move insert iterator that move constructs elements at the
-//! back of a container
-template <typename C> // C models Container
-class back_move_insert_iterator
- : public std::iterator<std::output_iterator_tag, void, void, void, void>
-{
- C* container_m;
-
- public:
- typedef C container_type;
-
- explicit back_move_insert_iterator(C& x) : container_m(&x) { }
-
- back_move_insert_iterator& operator=(typename C::reference x)
- { container_m->push_back(BOOST_MOVE_NAMESPACE::move(x)); return *this; }
-
- back_move_insert_iterator& operator*() { return *this; }
- back_move_insert_iterator& operator++() { return *this; }
- back_move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: back_move_insert_iterator<C>(x).
-template <typename C> // C models Container
-inline back_move_insert_iterator<C> back_move_inserter(C& x)
-{
- return back_move_insert_iterator<C>(x);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// front_move_insert_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! A move insert iterator that move constructs elements int the
-//! front of a container
-template <typename C> // C models Container
-class front_move_insert_iterator
- : public std::iterator<std::output_iterator_tag, void, void, void, void>
-{
- C* container_m;
-
-public:
- typedef C container_type;
-
- explicit front_move_insert_iterator(C& x) : container_m(&x) { }
-
- front_move_insert_iterator& operator=(typename C::reference x)
- { container_m->push_front(BOOST_MOVE_NAMESPACE::move(x)); return *this; }
-
- front_move_insert_iterator& operator*() { return *this; }
- front_move_insert_iterator& operator++() { return *this; }
- front_move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: front_move_insert_iterator<C>(x).
-template <typename C> // C models Container
-inline front_move_insert_iterator<C> front_move_inserter(C& x)
-{
- return front_move_insert_iterator<C>(x);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// insert_move_iterator
-//
-//////////////////////////////////////////////////////////////////////////////
-template <typename C> // C models Container
-class move_insert_iterator
- : public std::iterator<std::output_iterator_tag, void, void, void, void>
-{
- C* container_m;
- typename C::iterator pos_;
-
- public:
- typedef C container_type;
-
- explicit move_insert_iterator(C& x, typename C::iterator pos)
- : container_m(&x), pos_(pos)
- {}
-
- move_insert_iterator& operator=(typename C::reference x)
- {
- pos_ = container_m->insert(pos_, ::BOOST_MOVE_NAMESPACE::move(x));
- ++pos_;
- return *this;
- }
-
- move_insert_iterator& operator*() { return *this; }
- move_insert_iterator& operator++() { return *this; }
- move_insert_iterator& operator++(int) { return *this; }
-};
-
-//!
-//! <b>Returns</b>: move_insert_iterator<C>(x, it).
-template <typename C> // C models Container
-inline move_insert_iterator<C> move_inserter(C& x, typename C::iterator it)
-{
- return move_insert_iterator<C>(x, it);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-
-//! <b>Effects</b>: 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::move (*(first + n)).
-//!
-//! <b>Effects</b>: result + (last - first).
-//!
-//! <b>Requires</b>: result shall not be in the range [first,last).
-//!
-//! <b>Complexity</b>: Exactly last - first move assignments.
-template <typename I, // I models InputIterator
- typename O> // O models OutputIterator
-O move(I f, I l, O result)
-{
- while (f != l) {
- *result = ::BOOST_MOVE_NAMESPACE::move(*f);
- ++f; ++result;
- }
- return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// move_backward
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! <b>Effects</b>: 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::move(*(last - n)).
-//!
-//! <b>Requires</b>: result shall not be in the range [first,last).
-//!
-//! <b>Returns</b>: result - (last - first).
-//!
-//! <b>Complexity</b>: Exactly last - first assignments.
-template <typename I, // I models BidirectionalIterator
-typename O> // O models BidirectionalIterator
-O move_backward(I f, I l, O result)
-{
- while (f != l) {
- --l; --result;
- *result = ::BOOST_MOVE_NAMESPACE::move(*l);
- }
- return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// uninitialized_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! new (static_cast<void*>(&*result))
-//! typename iterator_traits<ForwardIterator>::value_type(boost::move(*first));
-//! \endcode
-//!
-//! <b>Returns</b>: result
-template
- <typename I, // I models InputIterator
- typename F> // F models ForwardIterator
-F uninitialized_move(I f, I l, F r
- /// @cond
- ,typename enable_if<is_movable<typename std::iterator_traits<I>::value_type> >::type* = 0
- /// @endcond
- )
-{
- typedef typename std::iterator_traits<I>::value_type input_value_type;
- while (f != l) {
- ::new(static_cast<void*>(&*r)) input_value_type(BOOST_MOVE_NAMESPACE::move(*f));
- ++f; ++r;
- }
- return r;
-}
-
-/// @cond
-
-template
- <typename I, // I models InputIterator
- typename F> // F models ForwardIterator
-F uninitialized_move(I f, I l, F r,
- typename disable_if<is_movable<typename std::iterator_traits<I>::value_type> >::type* = 0)
-{
- return std::uninitialized_copy(f, l, r);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// uninitialized_copy_or_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F uninitialized_move_move_iterator(I f, I l, F r,
- typename enable_if< is_movable<typename I::value_type> >::type* = 0)
-{
- return ::BOOST_MOVE_NAMESPACE::uninitialized_move(f, l, r);
-}
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F uninitialized_move_move_iterator(I f, I l, F r,
- typename disable_if< is_movable<typename I::value_type> >::type* = 0)
-{
- return std::uninitialized_copy(f.base(), l.base(), r);
-}
-
-} //namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F uninitialized_copy_or_move(I f, I l, F r,
- typename enable_if< move_detail::is_move_iterator<I> >::type* = 0)
-{
- return ::BOOST_MOVE_NAMESPACE::move_detail::uninitialized_move_move_iterator(f, l, r);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// copy_or_move
-//
-//////////////////////////////////////////////////////////////////////////////
-
-namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F move_move_iterator(I f, I l, F r,
- typename enable_if< is_movable<typename I::value_type> >::type* = 0)
-{
- return ::BOOST_MOVE_NAMESPACE::move(f, l, r);
-}
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F move_move_iterator(I f, I l, F r,
- typename disable_if< is_movable<typename I::value_type> >::type* = 0)
-{
- return std::copy(f.base(), l.base(), r);
-}
-
-
-} //namespace move_detail {
-
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F copy_or_move(I f, I l, F r,
- typename enable_if< move_detail::is_move_iterator<I> >::type* = 0)
-{
- return ::BOOST_MOVE_NAMESPACE::move_detail::move_move_iterator(f, l, r);
-}
-
-/// @endcond
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! new (static_cast<void*>(&*result))
-//! typename iterator_traits<ForwardIterator>::value_type(*first);
-//! \endcode
-//!
-//! <b>Returns</b>: result
-//!
-//! <b>Note</b>: This function is provided because
-//! <i>std::uninitialized_copy</i> from some STL implementations
-//! is not compatible with <i>move_iterator</i>
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F uninitialized_copy_or_move(I f, I l, F r
- /// @cond
- ,typename disable_if< move_detail::is_move_iterator<I> >::type* = 0
- /// @endcond
- )
-{
- return std::uninitialized_copy(f, l, r);
-}
-
-//! <b>Effects</b>:
-//! \code
-//! for (; first != last; ++result, ++first)
-//! *result = *first;
-//! \endcode
-//!
-//! <b>Returns</b>: result
-//!
-//! <b>Note</b>: This function is provided because
-//! <i>std::uninitialized_copy</i> from some STL implementations
-//! is not compatible with <i>move_iterator</i>
-template
-<typename I, // I models InputIterator
-typename F> // F models ForwardIterator
-F copy_or_move(I f, I l, F r
- /// @cond
- ,typename disable_if< move_detail::is_move_iterator<I> >::type* = 0
- /// @endcond
- )
-{
- return std::copy(f, l, r);
-}
-
-//! If this trait yields to true
-//! (<i>has_trivial_destructor_after_move <T>::value == true</i>)
-//! means that if T is used as argument of a move construction/assignment,
-//! there is no need to call T's destructor.
-//! This optimization tipically is used to improve containers' performance.
-//!
-//! By default this trait is true if the type has trivial destructor,
-//! every class should specialize this trait if it wants to improve performance
-//! when inserted in containers.
-template <class T>
-struct has_trivial_destructor_after_move
- : public ::boost::has_trivial_destructor<T>
-{};
-
-#ifndef BOOST_MOVE_DOXYGEN_INVOKED
-
-#ifdef BOOST_MOVE_IN_BOOST_INTERPROCESS_NAMESPACE
-
-#define BOOST_INTERPROCESS_ENABLE_MOVE_EMULATION(TYPE) BOOST_ENABLE_MOVE_EMULATION(TYPE)
-#define BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)
-#define BOOST_INTERPROCESS_COPYABLE_AND_MOVABLE(TYPE) BOOST_COPYABLE_AND_MOVABLE(TYPE)
-#define BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_INTERPROCESS_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_INTERPROCESS_RV_REF(TYPE) BOOST_RV_REF(TYPE)
-#define BOOST_INTERPROCESS_COPY_ASSIGN_REF(TYPE) BOOST_COPY_ASSIGN_REF(TYPE)
-#define BOOST_INTERPROCESS_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_INTERPROCESS_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_INTERPROCESS_FWD_REF(TYPE) BOOST_FWD_REF(TYPE)
-#define BOOST_INTERPROCESS_CATCH_CONST_RLVALUE(TYPE) BOOST_CATCH_CONST_RLVALUE(TYPE)
-
-#endif
-
-#define BOOST_MOVE_MACRO_ENABLE_MOVE_EMULATION(TYPE) BOOST_ENABLE_MOVE_EMULATION(TYPE)
-#define BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)
-#define BOOST_MOVE_MACRO_COPYABLE_AND_MOVABLE(TYPE) BOOST_COPYABLE_AND_MOVABLE(TYPE)
-#define BOOST_MOVE_MACRO_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_MOVE_MACRO_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_MOVE_MACRO_RV_REF(TYPE) BOOST_RV_REF(TYPE)
-#define BOOST_MOVE_MACRO_COPY_ASSIGN_REF(TYPE) BOOST_COPY_ASSIGN_REF(TYPE)
-#define BOOST_MOVE_MACRO_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2) BOOST_COPY_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)
-#define BOOST_MOVE_MACRO_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3) BOOST_COPY_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)
-#define BOOST_MOVE_MACRO_FWD_REF(TYPE) BOOST_FWD_REF(TYPE)
-#define BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(TYPE) BOOST_CATCH_CONST_RLVALUE(TYPE)
+namespace interprocess {
-#endif //BOOST_MOVE_DOXYGEN_INVOKED
+using ::boost::move;
+using ::boost::forward;
-INTERPROCESS_NAMESPACE_END
+} //namespace interprocess {
} //namespace boost {
-#endif //#ifndef BOOST_MOVE_HPP
+#endif //#ifndef BOOST_INTERPROCESS_DETAIL_MOVE_HPP
Modified: trunk/boost/interprocess/detail/segment_manager_helper.hpp
==============================================================================
--- trunk/boost/interprocess/detail/segment_manager_helper.hpp (original)
+++ trunk/boost/interprocess/detail/segment_manager_helper.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -25,6 +25,8 @@
#include <boost/interprocess/detail/utilities.hpp>
#include <boost/interprocess/detail/in_place_interface.hpp>
#include <boost/interprocess/exceptions.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/alignment_of.hpp>
#include <cstddef> //std::size_t
#include <string> //char_traits
#include <new> //std::nothrow
@@ -70,24 +72,25 @@
};
/// @cond
+template<class size_type>
struct block_header
{
- std::size_t m_value_bytes;
+ size_type m_value_bytes;
unsigned short m_num_char;
unsigned char m_value_alignment;
unsigned char m_alloc_type_sizeof_char;
- block_header(std::size_t value_bytes
- ,std::size_t value_alignment
- ,std::size_t alloc_type
+ block_header(size_type value_bytes
+ ,size_type value_alignment
+ ,unsigned char alloc_type
,std::size_t sizeof_char
,std::size_t num_char
)
: m_value_bytes(value_bytes)
- , m_num_char(num_char)
- , m_value_alignment(value_alignment)
+ , m_num_char((unsigned short)num_char)
+ , m_value_alignment((unsigned char)value_alignment)
, m_alloc_type_sizeof_char
- ( ((unsigned char)alloc_type << 5u) |
+ ( (alloc_type << 5u) |
((unsigned char)sizeof_char & 0x1F) )
{};
@@ -96,32 +99,32 @@
block_header &operator= (const T& )
{ return *this; }
- std::size_t total_size() const
+ size_type total_size() const
{
if(alloc_type() != anonymous_type){
return name_offset() + (m_num_char+1)*sizeof_char();
}
else{
- return value_offset() + m_value_bytes;
+ return this->value_offset() + m_value_bytes;
}
}
- std::size_t value_bytes() const
+ size_type value_bytes() const
{ return m_value_bytes; }
template<class Header>
- std::size_t total_size_with_header() const
+ size_type total_size_with_header() const
{
return get_rounded_size
- ( sizeof(Header)
- , detail::alignment_of<block_header>::value)
+ ( size_type(sizeof(Header))
+ , size_type(::boost::alignment_of<block_header<size_type> >::value))
+ total_size();
}
- std::size_t alloc_type() const
+ unsigned char alloc_type() const
{ return (m_alloc_type_sizeof_char >> 5u)&(unsigned char)0x7; }
- std::size_t sizeof_char() const
+ unsigned char sizeof_char() const
{ return m_alloc_type_sizeof_char & (unsigned char)0x1F; }
template<class CharType>
@@ -131,26 +134,26 @@
(reinterpret_cast<const char*>(this) + name_offset()));
}
- std::size_t name_length() const
+ unsigned short name_length() const
{ return m_num_char; }
- std::size_t name_offset() const
+ size_type name_offset() const
{
- return value_offset() + get_rounded_size(m_value_bytes, sizeof_char());
+ return this->value_offset() + get_rounded_size(size_type(m_value_bytes), size_type(sizeof_char()));
}
void *value() const
{
- return const_cast<char*>((reinterpret_cast<const char*>(this) + value_offset()));
+ return const_cast<char*>((reinterpret_cast<const char*>(this) + this->value_offset()));
}
- std::size_t value_offset() const
+ size_type value_offset() const
{
- return get_rounded_size(sizeof(block_header), m_value_alignment);
+ return get_rounded_size(size_type(sizeof(block_header<size_type>)), size_type(m_value_alignment));
}
template<class CharType>
- bool less_comp(const block_header &b) const
+ bool less_comp(const block_header<size_type> &b) const
{
return m_num_char < b.m_num_char ||
(m_num_char < b.m_num_char &&
@@ -159,7 +162,7 @@
}
template<class CharType>
- bool equal_comp(const block_header &b) const
+ bool equal_comp(const block_header<size_type> &b) const
{
return m_num_char == b.m_num_char &&
std::char_traits<CharType>::compare
@@ -167,10 +170,10 @@
}
template<class T>
- static block_header *block_header_from_value(T *value)
- { return block_header_from_value(value, sizeof(T), detail::alignment_of<T>::value); }
+ static block_header<size_type> *block_header_from_value(T *value)
+ { return block_header_from_value(value, sizeof(T), ::boost::alignment_of<T>::value); }
- static block_header *block_header_from_value(const void *value, std::size_t sz, std::size_t algn)
+ static block_header<size_type> *block_header_from_value(const void *value, std::size_t sz, std::size_t algn)
{
block_header * hdr =
const_cast<block_header*>
@@ -184,21 +187,21 @@
}
template<class Header>
- static block_header *from_first_header(Header *header)
+ static block_header<size_type> *from_first_header(Header *header)
{
- block_header * hdr =
- reinterpret_cast<block_header*>(reinterpret_cast<char*>(header) +
- get_rounded_size(sizeof(Header), detail::alignment_of<block_header>::value));
+ block_header<size_type> * hdr =
+ reinterpret_cast<block_header<size_type>*>(reinterpret_cast<char*>(header) +
+ get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));
//Some sanity checks
return hdr;
}
template<class Header>
- static Header *to_first_header(block_header *bheader)
+ static Header *to_first_header(block_header<size_type> *bheader)
{
Header * hdr =
reinterpret_cast<Header*>(reinterpret_cast<char*>(bheader) -
- get_rounded_size(sizeof(Header), detail::alignment_of<block_header>::value));
+ get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));
//Some sanity checks
return hdr;
}
@@ -257,7 +260,7 @@
typedef instance_t<unique_type> unique_instance_t;
-template<class Hook, class CharType>
+template<class Hook, class CharType, class SizeType>
struct intrusive_value_type_impl
: public Hook
{
@@ -268,34 +271,35 @@
public:
typedef CharType char_type;
+ typedef SizeType size_type;
intrusive_value_type_impl(){}
- enum { BlockHdrAlignment = detail::alignment_of<block_header>::value };
+ enum { BlockHdrAlignment = ::boost::alignment_of<block_header<size_type> >::value };
- block_header *get_block_header() const
+ block_header<size_type> *get_block_header() const
{
- return const_cast<block_header*>
- (reinterpret_cast<const block_header *>(reinterpret_cast<const char*>(this) +
- get_rounded_size(sizeof(*this), BlockHdrAlignment)));
+ return const_cast<block_header<size_type>*>
+ (reinterpret_cast<const block_header<size_type> *>(reinterpret_cast<const char*>(this) +
+ ::boost::interprocess::detail::get_rounded_size(size_type(sizeof(*this)), size_type(BlockHdrAlignment))));
}
- bool operator <(const intrusive_value_type_impl<Hook, CharType> & other) const
+ bool operator <(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
{ return (this->get_block_header())->template less_comp<CharType>(*other.get_block_header()); }
- bool operator ==(const intrusive_value_type_impl<Hook, CharType> & other) const
+ bool operator ==(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
{ return (this->get_block_header())->template equal_comp<CharType>(*other.get_block_header()); }
- static intrusive_value_type_impl *get_intrusive_value_type(block_header *hdr)
+ static intrusive_value_type_impl *get_intrusive_value_type(block_header<size_type> *hdr)
{
return reinterpret_cast<intrusive_value_type_impl *>(reinterpret_cast<char*>(hdr) -
- get_rounded_size(sizeof(intrusive_value_type_impl), BlockHdrAlignment));
+ get_rounded_size(size_type(sizeof(intrusive_value_type_impl)), size_type(BlockHdrAlignment)));
}
CharType *name() const
{ return get_block_header()->template name<CharType>(); }
- std::size_t name_length() const
+ unsigned short name_length() const
{ return get_block_header()->name_length(); }
void *value() const
@@ -333,16 +337,18 @@
typedef typename boost::
pointer_to_other<VoidPointer, const CharT>::type const_char_ptr_t;
typedef CharT char_type;
+ typedef typename std::iterator_traits<const_char_ptr_t>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
private:
//Offset pointer to the object's name
const_char_ptr_t mp_str;
//Length of the name buffer (null NOT included)
- std::size_t m_len;
+ size_type m_len;
public:
//!Constructor of the key
- index_key (const char_type *name, std::size_t length)
+ index_key (const char_type *name, size_type length)
: mp_str(name), m_len(length) {}
//!Less than function for index ordering
@@ -352,7 +358,7 @@
(m_len == right.m_len &&
std::char_traits<char_type>::compare
(detail::get_pointer(mp_str)
- ,detail::get_pointer(right.mp_str), m_len) < 0);
+ ,detail::get_pointer(right.mp_str), m_len) < 0);
}
//!Equal to function for index ordering
@@ -367,13 +373,13 @@
void name(const CharT *name)
{ mp_str = name; }
- void name_length(std::size_t len)
+ void name_length(size_type len)
{ m_len = len; }
const CharT *name() const
{ return detail::get_pointer(mp_str); }
- std::size_t name_length() const
+ size_type name_length() const
{ return m_len; }
};
@@ -406,7 +412,7 @@
template<class HeaderBase>
struct intrusive_value_type
- { typedef detail::intrusive_value_type_impl<HeaderBase, CharT> type; };
+ { typedef detail::intrusive_value_type_impl<HeaderBase, CharT, typename segment_manager_base::size_type> type; };
typedef intrusive_compare_key<CharT> intrusive_compare_key_type;
};
@@ -425,7 +431,7 @@
const char_type *name() const
{ return m_val->name(); }
- std::size_t name_length() const
+ unsigned short name_length() const
{ return m_val->name_length(); }
const void *value() const
@@ -442,6 +448,7 @@
typedef typename iterator_val_t::first_type first_type;
typedef typename iterator_val_t::second_type second_type;
typedef typename first_type::char_type char_type;
+ typedef typename first_type::size_type size_type;
public:
segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val)
@@ -451,12 +458,12 @@
const char_type *name() const
{ return m_val->first.name(); }
- std::size_t name_length() const
+ size_type name_length() const
{ return m_val->first.name_length(); }
const void *value() const
{
- return reinterpret_cast<block_header*>
+ return reinterpret_cast<block_header<size_type>*>
(detail::get_pointer(m_val->second.m_ptr))->value();
}
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -52,7 +52,7 @@
// FreeBSD specific: sysctl "kern.boottime"
int request[2] = { CTL_KERN, KERN_BOOTTIME };
struct ::timeval result;
- size_t result_len = sizeof result;
+ std::size_t result_len = sizeof result;
if (::sysctl (request, 2, &result, &result_len, NULL, 0) < 0)
return;
Modified: trunk/boost/interprocess/detail/type_traits.hpp
==============================================================================
--- trunk/boost/interprocess/detail/type_traits.hpp (original)
+++ trunk/boost/interprocess/detail/type_traits.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -8,8 +8,6 @@
//
// See http://www.boost.org/libs/interprocess for documentation.
//
-// The alignment_of implementation comes from John Maddock's boost::alignment_of code
-//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
@@ -27,48 +25,6 @@
struct nat{};
-//boost::alignment_of yields to 10K lines of preprocessed code, so we
-//need an alternative
-template <typename T> struct alignment_of;
-
-template <typename T>
-struct alignment_of_hack
-{
- char c;
- T t;
- alignment_of_hack();
-};
-
-template <unsigned A, unsigned S>
-struct alignment_logic
-{
- enum{ value = A < S ? A : S };
-};
-
-template< typename T >
-struct alignment_of
-{
- enum{ value = alignment_logic
- < sizeof(alignment_of_hack<T>) - sizeof(T)
- , sizeof(T)>::value };
-};
-
-//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>
struct remove_reference
{
Modified: trunk/boost/interprocess/detail/utilities.hpp
==============================================================================
--- trunk/boost/interprocess/detail/utilities.hpp (original)
+++ trunk/boost/interprocess/detail/utilities.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -70,25 +70,29 @@
}
//Rounds "orig_size" by excess to round_to bytes
-inline std::size_t get_rounded_size(std::size_t orig_size, std::size_t round_to)
+template<class SizeType>
+inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
{
return ((orig_size-1)/round_to+1)*round_to;
}
//Truncates "orig_size" to a multiple of "multiple" bytes.
-inline std::size_t get_truncated_size(std::size_t orig_size, std::size_t multiple)
+template<class SizeType>
+inline SizeType get_truncated_size(SizeType orig_size, SizeType multiple)
{
return orig_size/multiple*multiple;
}
//Rounds "orig_size" by excess to round_to bytes. round_to must be power of two
-inline std::size_t get_rounded_size_po2(std::size_t orig_size, std::size_t round_to)
+template<class SizeType>
+inline SizeType get_rounded_size_po2(SizeType orig_size, SizeType round_to)
{
return ((orig_size-1)&(~(round_to-1))) + round_to;
}
//Truncates "orig_size" to a multiple of "multiple" bytes. multiple must be power of two
-inline std::size_t get_truncated_size_po2(std::size_t orig_size, std::size_t multiple)
+template<class SizeType>
+inline SizeType get_truncated_size_po2(SizeType orig_size, SizeType multiple)
{
return (orig_size & (~(multiple-1)));
}
Modified: trunk/boost/interprocess/detail/xsi_shared_memory_device.hpp
==============================================================================
--- trunk/boost/interprocess/detail/xsi_shared_memory_device.hpp (original)
+++ trunk/boost/interprocess/detail/xsi_shared_memory_device.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -45,7 +45,7 @@
class xsi_shared_memory_device
{
/// @cond
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
/// @endcond
public:
@@ -70,10 +70,10 @@
xsi_shared_memory_device(open_only_t, const char *filepath, boost::uint8_t id, mode_t mode)
{ this->priv_open_or_create_name_id(detail::DoOpen, name, id, mode, 0); }
- xsi_shared_memory_device(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_device) moved)
+ xsi_shared_memory_device(BOOST_RV_REF(xsi_shared_memory_device) moved)
{ this->swap(moved); }
- xsi_shared_memory_device &operator=(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_device) moved)
+ xsi_shared_memory_device &operator=(BOOST_RV_REF(xsi_shared_memory_device) moved)
{
xsi_shared_memory_device tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp
==============================================================================
--- trunk/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp (original)
+++ trunk/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -39,7 +39,7 @@
: public xsi_shared_memory
{
/// @cond
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
/// @endcond
public:
@@ -57,10 +57,10 @@
: xsi_shared_memory(open_only_t(), key)
{}
- xsi_shared_memory_file_wrapper(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_file_wrapper) moved)
+ xsi_shared_memory_file_wrapper(BOOST_RV_REF(xsi_shared_memory_file_wrapper) moved)
{ this->swap(moved); }
- xsi_shared_memory_file_wrapper &operator=(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_file_wrapper) moved)
+ xsi_shared_memory_file_wrapper &operator=(BOOST_RV_REF(xsi_shared_memory_file_wrapper) moved)
{
xsi_shared_memory_file_wrapper tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/file_mapping.hpp
==============================================================================
--- trunk/boost/interprocess/file_mapping.hpp (original)
+++ trunk/boost/interprocess/file_mapping.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -33,7 +33,7 @@
class file_mapping
{
/// @cond
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(file_mapping)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(file_mapping)
/// @endcond
public:
@@ -50,14 +50,14 @@
//!Moves the ownership of "moved"'s file mapping object to *this.
//!After the call, "moved" does not represent any file mapping object.
//!Does not throw
- file_mapping(BOOST_INTERPROCESS_RV_REF(file_mapping) moved)
+ file_mapping(BOOST_RV_REF(file_mapping) moved)
: m_handle(file_handle_t(detail::invalid_file()))
{ this->swap(moved); }
//!Moves the ownership of "moved"'s file mapping to *this.
//!After the call, "moved" does not represent any file mapping.
//!Does not throw
- file_mapping &operator=(BOOST_INTERPROCESS_RV_REF(file_mapping) moved)
+ file_mapping &operator=(BOOST_RV_REF(file_mapping) moved)
{
file_mapping tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/indexes/flat_map_index.hpp
==============================================================================
--- trunk/boost/interprocess/indexes/flat_map_index.hpp (original)
+++ trunk/boost/interprocess/indexes/flat_map_index.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -63,7 +63,7 @@
{}
//!This reserves memory to optimize the insertion of n elements in the index
- void reserve(std::size_t n)
+ void reserve(typename segment_manager_base::size_type n)
{ base_type::reserve(n); }
//!This frees all unnecessary memory
Modified: trunk/boost/interprocess/indexes/iset_index.hpp
==============================================================================
--- trunk/boost/interprocess/indexes/iset_index.hpp (original)
+++ trunk/boost/interprocess/indexes/iset_index.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -112,7 +112,7 @@
//!This reserves memory to optimize the insertion of n
//!elements in the index
- void reserve(std::size_t)
+ void reserve(typename MapConfig::segment_manager_base::size_type)
{ /*Does nothing, map has not reserve or rehash*/ }
//!This frees all unnecessary memory
Modified: trunk/boost/interprocess/indexes/iunordered_set_index.hpp
==============================================================================
--- trunk/boost/interprocess/indexes/iunordered_set_index.hpp (original)
+++ trunk/boost/interprocess/indexes/iunordered_set_index.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -101,6 +101,7 @@
< value_type
, bi::hash<hash_function>
, bi::equal<equal_function>
+ , bi::size_type<typename segment_manager_base::size_type>
>::type index_t;
typedef typename index_t::bucket_type bucket_type;
typedef allocator
@@ -157,24 +158,24 @@
enum { InitBufferSize = 64};
- static bucket_ptr create_buckets(allocator_type &alloc, std::size_t num)
+ static bucket_ptr create_buckets(allocator_type &alloc, size_type num)
{
num = index_type::suggested_upper_bucket_count(num);
bucket_ptr buckets = alloc.allocate(num);
bucket_ptr buckets_init = buckets;
- for(std::size_t i = 0; i < num; ++i){
+ for(size_type i = 0; i < num; ++i){
new(get_pointer(buckets_init++))bucket_type();
}
return buckets;
}
- static std::size_t shrink_buckets
- ( bucket_ptr buckets, std::size_t old_size
- , allocator_type &alloc, std::size_t new_size)
+ static size_type shrink_buckets
+ ( bucket_ptr buckets, size_type old_size
+ , allocator_type &alloc, size_type new_size)
{
if(old_size <= new_size )
return old_size;
- std::size_t received_size;
+ size_type received_size;
if(!alloc.allocation_command
(boost::interprocess::try_shrink_in_place | boost::interprocess::nothrow_allocation, old_size, new_size, received_size, buckets).first){
return old_size;
@@ -192,29 +193,29 @@
BOOST_ASSERT(buckets == shunk_p);
bucket_ptr buckets_init = buckets + received_size;
- for(std::size_t i = 0; i < (old_size - received_size); ++i){
+ for(size_type i = 0; i < (old_size - received_size); ++i){
get_pointer(buckets_init++)->~bucket_type();
}
return received_size;
}
static bucket_ptr expand_or_create_buckets
- ( bucket_ptr old_buckets, const std::size_t old_num
- , allocator_type &alloc, const std::size_t new_num)
+ ( bucket_ptr old_buckets, const size_type old_num
+ , allocator_type &alloc, const size_type new_num)
{
- std::size_t received_size;
+ size_type received_size;
std::pair<bucket_ptr, bool> ret =
alloc.allocation_command
(boost::interprocess::expand_fwd | boost::interprocess::allocate_new, new_num, new_num, received_size, old_buckets);
if(ret.first == old_buckets){
bucket_ptr buckets_init = old_buckets + old_num;
- for(std::size_t i = 0; i < (new_num - old_num); ++i){
+ for(size_type i = 0; i < (new_num - old_num); ++i){
new(get_pointer(buckets_init++))bucket_type();
}
}
else{
bucket_ptr buckets_init = ret.first;
- for(std::size_t i = 0; i < new_num; ++i){
+ for(size_type i = 0; i < new_num; ++i){
new(get_pointer(buckets_init++))bucket_type();
}
}
@@ -223,10 +224,10 @@
}
static void destroy_buckets
- (allocator_type &alloc, bucket_ptr buckets, std::size_t num)
+ (allocator_type &alloc, bucket_ptr buckets, size_type num)
{
bucket_ptr buckets_destroy = buckets;
- for(std::size_t i = 0; i < num; ++i){
+ for(size_type i = 0; i < num; ++i){
get_pointer(buckets_destroy++)->~bucket_type();
}
alloc.deallocate(buckets, num);
@@ -255,7 +256,7 @@
//!This reserves memory to optimize the insertion of n
//!elements in the index
- void reserve(std::size_t new_n)
+ void reserve(size_type new_n)
{
//Let's maintain a 1.0f load factor
size_type old_n = this->bucket_count();
Modified: trunk/boost/interprocess/indexes/map_index.hpp
==============================================================================
--- trunk/boost/interprocess/indexes/map_index.hpp (original)
+++ trunk/boost/interprocess/indexes/map_index.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -71,7 +71,7 @@
//!This reserves memory to optimize the insertion of n
//!elements in the index
- void reserve(std::size_t)
+ void reserve(typename segment_manager_base::size_type)
{ /*Does nothing, map has not reserve or rehash*/ }
//!This tries to free previously allocate
Modified: trunk/boost/interprocess/indexes/unordered_map_index.hpp
==============================================================================
--- trunk/boost/interprocess/indexes/unordered_map_index.hpp (original)
+++ trunk/boost/interprocess/indexes/unordered_map_index.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -84,7 +84,7 @@
//!This reserves memory to optimize the insertion of n
//!elements in the index
- void reserve(std::size_t n)
+ void reserve(typename segment_manager_base::size_type n)
{ base_type::rehash(n); }
//!This tries to free previously allocate
Modified: trunk/boost/interprocess/interprocess_fwd.hpp
==============================================================================
--- trunk/boost/interprocess/interprocess_fwd.hpp (original)
+++ trunk/boost/interprocess/interprocess_fwd.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -158,7 +158,9 @@
// offset_ptr
//////////////////////////////////////////////////////////////////////////////
-template <class T>
+static const std::size_t offset_type_alignment = 0;
+
+template <class T, class DifferenceType = std::ptrdiff_t, class OffsetType = std::size_t, std::size_t Alignment = offset_type_alignment>
class offset_ptr;
//////////////////////////////////////////////////////////////////////////////
@@ -410,7 +412,10 @@
// IPC
//////////////////////////////////////////////////////////////////////////////
-class message_queue;
+template<class VoidPointer>
+class message_queue_t;
+
+typedef message_queue_t<offset_ptr<void> > message_queue;
}} //namespace boost { namespace interprocess {
Modified: trunk/boost/interprocess/ipc/message_queue.hpp
==============================================================================
--- trunk/boost/interprocess/ipc/message_queue.hpp (original)
+++ trunk/boost/interprocess/ipc/message_queue.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -25,7 +25,9 @@
#include <boost/interprocess/permissions.hpp>
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/interprocess/detail/type_traits.hpp>
-
+#include <boost/pointer_to_other.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/alignment_of.hpp>
#include <algorithm> //std::lower_bound
#include <cstddef> //std::size_t
#include <cstring> //memcpy
@@ -40,24 +42,29 @@
//!A class that allows sending messages
//!between processes.
-class message_queue
+template<class VoidPointer>
+class message_queue_t
{
/// @cond
//Blocking modes
enum block_t { blocking, timed, non_blocking };
- message_queue();
+ message_queue_t();
/// @endcond
public:
+ typedef VoidPointer void_pointer;
+ typedef typename boost::pointer_to_other<void_pointer, char>::type char_ptr;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
//!Creates a process shared message queue with name "name". For this message queue,
//!the maximum number of messages will be "max_num_msg" and the maximum message size
//!will be "max_msg_size". Throws on error and if the queue was previously created.
- message_queue(create_only_t create_only,
+ message_queue_t(create_only_t create_only,
const char *name,
- std::size_t max_num_msg,
- std::size_t max_msg_size,
+ size_type max_num_msg,
+ size_type max_msg_size,
const permissions &perm = permissions());
//!Opens or creates a process shared message queue with name "name".
@@ -65,16 +72,16 @@
//!and the maximum message size will be "max_msg_size". If queue was previously
//!created the queue will be opened and "max_num_msg" and "max_msg_size" parameters
//!are ignored. Throws on error.
- message_queue(open_or_create_t open_or_create,
+ message_queue_t(open_or_create_t open_or_create,
const char *name,
- std::size_t max_num_msg,
- std::size_t max_msg_size,
+ size_type max_num_msg,
+ size_type max_msg_size,
const permissions &perm = permissions());
//!Opens a previously created process shared message queue with name "name".
//!If the was not previously created or there are no free resources,
//!throws an error.
- message_queue(open_only_t open_only,
+ message_queue_t(open_only_t open_only,
const char *name);
//!Destroys *this and indicates that the calling process is finished using
@@ -84,19 +91,19 @@
//!this resource. The resource can still be opened again calling
//!the open constructor overload. To erase the message queue from the system
//!use remove().
- ~message_queue();
+ ~message_queue_t();
//!Sends a message stored in buffer "buffer" with size "buffer_size" in the
//!message queue with priority "priority". If the message queue is full
//!the sender is blocked. Throws interprocess_error on error.*/
- void send (const void *buffer, std::size_t buffer_size,
+ void send (const void *buffer, size_type buffer_size,
unsigned int priority);
//!Sends a message stored in buffer "buffer" with size "buffer_size" through the
//!message queue with priority "priority". If the message queue is full
//!the sender is not blocked and returns false, otherwise returns true.
//!Throws interprocess_error on error.
- bool try_send (const void *buffer, std::size_t buffer_size,
+ bool try_send (const void *buffer, size_type buffer_size,
unsigned int priority);
//!Sends a message stored in buffer "buffer" with size "buffer_size" in the
@@ -104,23 +111,23 @@
//!the sender retries until time "abs_time" is reached. Returns true if
//!the message has been successfully sent. Returns false if timeout is reached.
//!Throws interprocess_error on error.
- bool timed_send (const void *buffer, std::size_t buffer_size,
+ bool timed_send (const void *buffer, size_type buffer_size,
unsigned int priority, const boost::posix_time::ptime& abs_time);
//!Receives a message from the message queue. The message is stored in buffer
//!"buffer", which has size "buffer_size". The received message has size
//!"recvd_size" and priority "priority". If the message queue is empty
//!the receiver is blocked. Throws interprocess_error on error.
- void receive (void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size,unsigned int &priority);
+ void receive (void *buffer, size_type buffer_size,
+ size_type &recvd_size,unsigned int &priority);
//!Receives a message from the message queue. The message is stored in buffer
//!"buffer", which has size "buffer_size". The received message has size
//!"recvd_size" and priority "priority". If the message queue is empty
//!the receiver is not blocked and returns false, otherwise returns true.
//!Throws interprocess_error on error.
- bool try_receive (void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size,unsigned int &priority);
+ bool try_receive (void *buffer, size_type buffer_size,
+ size_type &recvd_size,unsigned int &priority);
//!Receives a message from the message queue. The message is stored in buffer
//!"buffer", which has size "buffer_size". The received message has size
@@ -128,23 +135,23 @@
//!the receiver retries until time "abs_time" is reached. Returns true if
//!the message has been successfully sent. Returns false if timeout is reached.
//!Throws interprocess_error on error.
- bool timed_receive (void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size,unsigned int &priority,
+ bool timed_receive (void *buffer, size_type buffer_size,
+ size_type &recvd_size,unsigned int &priority,
const boost::posix_time::ptime &abs_time);
//!Returns the maximum number of messages allowed by the queue. The message
//!queue must be opened or created previously. Otherwise, returns 0.
//!Never throws
- std::size_t get_max_msg() const;
+ size_type get_max_msg() const;
//!Returns the maximum size of message allowed by the queue. The message
//!queue must be opened or created previously. Otherwise, returns 0.
//!Never throws
- std::size_t get_max_msg_size() const;
+ size_type get_max_msg_size() const;
//!Returns the number of messages currently stored.
//!Never throws
- std::size_t get_num_msg();
+ size_type get_num_msg();
//!Removes the message queue from the system.
//!Returns false on error. Never throws
@@ -154,17 +161,17 @@
private:
typedef boost::posix_time::ptime ptime;
bool do_receive(block_t block,
- void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size, unsigned int &priority,
+ void *buffer, size_type buffer_size,
+ size_type &recvd_size, unsigned int &priority,
const ptime &abs_time);
bool do_send(block_t block,
- const void *buffer, std::size_t buffer_size,
+ const void *buffer, size_type buffer_size,
unsigned int priority, const ptime &abs_time);
//!Returns the needed memory size for the shared message queue.
//!Never throws
- static std::size_t get_mem_size(std::size_t max_msg_size, std::size_t max_num_msg);
+ static size_type get_mem_size(size_type max_msg_size, size_type max_num_msg);
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
/// @endcond
@@ -175,21 +182,32 @@
namespace detail {
//!This header is the prefix of each message in the queue
+template<class VoidPointer>
class msg_hdr_t
{
+ typedef VoidPointer void_pointer;
+ typedef typename boost::
+ pointer_to_other<VoidPointer, char>::type char_ptr;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+
public:
- std::size_t len; // Message length
+ size_type len; // Message length
unsigned int priority;// Message priority
//!Returns the data buffer associated with this this message
void * data(){ return this+1; } //
};
//!This functor is the predicate to order stored messages by priority
+template<class VoidPointer>
class priority_functor
{
+ typedef typename boost::
+ pointer_to_other<VoidPointer, msg_hdr_t<VoidPointer> >::type msg_hdr_ptr_t;
+
public:
- bool operator()(const offset_ptr<msg_hdr_t> &msg1,
- const offset_ptr<msg_hdr_t> &msg2) const
+ bool operator()(const msg_hdr_ptr_t &msg1,
+ const msg_hdr_ptr_t &msg2) const
{ return msg1->priority < msg2->priority; }
};
@@ -225,23 +243,32 @@
//! An array of buffers of preallocated messages, each one prefixed with the
//! msg_hdr_t structure. Each of this message is pointed by one pointer of
//! the index structure.
+template<class VoidPointer>
class mq_hdr_t
- : public detail::priority_functor
+ : public detail::priority_functor<VoidPointer>
{
- typedef offset_ptr<msg_hdr_t> msg_hdr_ptr_t;
+ typedef VoidPointer void_pointer;
+ typedef msg_hdr_t<void_pointer> msg_header;
+ typedef typename boost::
+ pointer_to_other<void_pointer, msg_header>::type msg_hdr_ptr_t;
+ typedef typename std::iterator_traits<msg_hdr_ptr_t>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+ typedef typename boost::
+ pointer_to_other<void_pointer, msg_hdr_ptr_t>::type msg_hdr_ptr_ptr_t;
+
public:
//!Constructor. This object must be constructed in the beginning of the
//!shared memory of the size returned by the function "get_mem_size".
//!This constructor initializes the needed resources and creates
//!the internal structures like the priority index. This can throw.*/
- mq_hdr_t(std::size_t max_num_msg, std::size_t max_msg_size)
+ mq_hdr_t(size_type max_num_msg, size_type max_msg_size)
: m_max_num_msg(max_num_msg),
m_max_msg_size(max_msg_size),
m_cur_num_msg(0)
{ this->initialize_memory(); }
//!Returns the inserted message with top priority
- msg_hdr_t * top_msg()
+ msg_header * top_msg()
{ return mp_index[m_cur_num_msg-1].get(); }
//!Returns true if the message queue is full
@@ -257,7 +284,7 @@
{ --m_cur_num_msg; }
//!Returns the first free msg of the free message queue
- msg_hdr_t * free_msg()
+ msg_header * free_msg()
{ return mp_index[m_cur_num_msg].get(); }
//!Inserts the first free message in the priority queue
@@ -268,7 +295,7 @@
//Get priority queue's range
msg_hdr_ptr_t *it = &mp_index[0], *it_end = &mp_index[m_cur_num_msg];
//Check where the free message should be placed
- it = std::lower_bound(it, it_end, free, static_cast<priority_functor&>(*this));
+ it = std::lower_bound(it, it_end, free, static_cast<priority_functor<VoidPointer>&>(*this));
//Make room in that position
std::copy_backward(it, it_end, it_end+1);
//Insert the free message in the correct position
@@ -279,15 +306,15 @@
//!Returns the number of bytes needed to construct a message queue with
//!"max_num_size" maximum number of messages and "max_msg_size" maximum
//!message size. Never throws.
- static std::size_t get_mem_size
- (std::size_t max_msg_size, std::size_t max_num_msg)
+ static size_type get_mem_size
+ (size_type max_msg_size, size_type max_num_msg)
{
- const std::size_t
- msg_hdr_align = detail::alignment_of<detail::msg_hdr_t>::value,
- index_align = detail::alignment_of<msg_hdr_ptr_t>::value,
+ const size_type
+ msg_hdr_align = ::boost::alignment_of<msg_header>::value,
+ index_align = ::boost::alignment_of<msg_hdr_ptr_t>::value,
r_hdr_size = detail::ct_rounded_size<sizeof(mq_hdr_t), index_align>::value,
r_index_size = detail::get_rounded_size(sizeof(msg_hdr_ptr_t)*max_num_msg, msg_hdr_align),
- r_max_msg_size = detail::get_rounded_size(max_msg_size, msg_hdr_align) + sizeof(detail::msg_hdr_t);
+ r_max_msg_size = detail::get_rounded_size(max_msg_size, msg_hdr_align) + sizeof(msg_header);
return r_hdr_size + r_index_size + (max_num_msg*r_max_msg_size) +
detail::managed_open_or_create_impl<shared_memory_object>::ManagedOpenOrCreateUserOffset;
}
@@ -296,41 +323,41 @@
//!message index. Never throws.
void initialize_memory()
{
- const std::size_t
- msg_hdr_align = detail::alignment_of<detail::msg_hdr_t>::value,
- index_align = detail::alignment_of<msg_hdr_ptr_t>::value,
+ const size_type
+ msg_hdr_align = ::boost::alignment_of<msg_header>::value,
+ index_align = ::boost::alignment_of<msg_hdr_ptr_t>::value,
r_hdr_size = detail::ct_rounded_size<sizeof(mq_hdr_t), index_align>::value,
r_index_size = detail::get_rounded_size(sizeof(msg_hdr_ptr_t)*m_max_num_msg, msg_hdr_align),
- r_max_msg_size = detail::get_rounded_size(m_max_msg_size, msg_hdr_align) + sizeof(detail::msg_hdr_t);
+ r_max_msg_size = detail::get_rounded_size(m_max_msg_size, msg_hdr_align) + sizeof(msg_header);
//Pointer to the index
msg_hdr_ptr_t *index = reinterpret_cast<msg_hdr_ptr_t*>
(reinterpret_cast<char*>(this)+r_hdr_size);
//Pointer to the first message header
- detail::msg_hdr_t *msg_hdr = reinterpret_cast<detail::msg_hdr_t*>
+ msg_header *msg_hdr = reinterpret_cast<msg_header*>
(reinterpret_cast<char*>(this)+r_hdr_size+r_index_size);
//Initialize the pointer to the index
mp_index = index;
//Initialize the index so each slot points to a preallocated message
- for(std::size_t i = 0; i < m_max_num_msg; ++i){
+ for(size_type i = 0; i < m_max_num_msg; ++i){
index[i] = msg_hdr;
- msg_hdr = reinterpret_cast<detail::msg_hdr_t*>
+ msg_hdr = reinterpret_cast<msg_header*>
(reinterpret_cast<char*>(msg_hdr)+r_max_msg_size);
}
}
public:
//Pointer to the index
- offset_ptr<msg_hdr_ptr_t> mp_index;
+ msg_hdr_ptr_ptr_t mp_index;
//Maximum number of messages of the queue
- const std::size_t m_max_num_msg;
+ const size_type m_max_num_msg;
//Maximum size of messages of the queue
- const std::size_t m_max_msg_size;
+ const size_type m_max_msg_size;
//Current number of messages
- std::size_t m_cur_num_msg;
+ size_type m_cur_num_msg;
//Mutex to protect data structures
interprocess_mutex m_mutex;
//Condition block receivers when there are no messages
@@ -342,14 +369,19 @@
//!This is the atomic functor to be executed when creating or opening
//!shared memory. Never throws
+template<class VoidPointer>
class initialization_func_t
{
public:
- initialization_func_t(std::size_t maxmsg = 0,
- std::size_t maxmsgsize = 0)
+ typedef typename boost::pointer_to_other<VoidPointer, char>::type char_ptr;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+
+ initialization_func_t(size_type maxmsg = 0,
+ size_type maxmsgsize = 0)
: m_maxmsg (maxmsg), m_maxmsgsize(maxmsgsize) {}
- bool operator()(void *address, std::size_t, bool created)
+ bool operator()(void *address, size_type, bool created)
{
char *mptr;
@@ -357,7 +389,7 @@
mptr = reinterpret_cast<char*>(address);
//Construct the message queue header at the beginning
BOOST_TRY{
- new (mptr) mq_hdr_t(m_maxmsg, m_maxmsgsize);
+ new (mptr) mq_hdr_t<VoidPointer>(m_maxmsg, m_maxmsgsize);
}
BOOST_CATCH(...){
return false;
@@ -366,39 +398,43 @@
}
return true;
}
- const std::size_t m_maxmsg;
- const std::size_t m_maxmsgsize;
+ const size_type m_maxmsg;
+ const size_type m_maxmsgsize;
};
} //namespace detail {
-inline message_queue::~message_queue()
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::~message_queue_t()
{}
-inline std::size_t message_queue::get_mem_size
- (std::size_t max_msg_size, std::size_t max_num_msg)
-{ return detail::mq_hdr_t::get_mem_size(max_msg_size, max_num_msg); }
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_mem_size
+ (size_type max_msg_size, size_type max_num_msg)
+{ return detail::mq_hdr_t<VoidPointer>::get_mem_size(max_msg_size, max_num_msg); }
-inline message_queue::message_queue(create_only_t create_only,
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(create_only_t create_only,
const char *name,
- std::size_t max_num_msg,
- std::size_t max_msg_size,
+ size_type max_num_msg,
+ size_type max_msg_size,
const permissions &perm)
//Create shared memory and execute functor atomically
: m_shmem(create_only,
name,
- get_mem_size(max_msg_size, max_num_msg),
+ get_mem_size(max_msg_size, max_num_msg),
read_write,
static_cast<void*>(0),
//Prepare initialization functor
- detail::initialization_func_t (max_num_msg, max_msg_size),
+ detail::initialization_func_t<VoidPointer> (max_num_msg, max_msg_size),
perm)
{}
-inline message_queue::message_queue(open_or_create_t open_or_create,
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(open_or_create_t open_or_create,
const char *name,
- std::size_t max_num_msg,
- std::size_t max_msg_size,
+ size_type max_num_msg,
+ size_type max_msg_size,
const permissions &perm)
//Create shared memory and execute functor atomically
: m_shmem(open_or_create,
@@ -407,11 +443,12 @@
read_write,
static_cast<void*>(0),
//Prepare initialization functor
- detail::initialization_func_t (max_num_msg, max_msg_size),
+ detail::initialization_func_t<VoidPointer> (max_num_msg, max_msg_size),
perm)
{}
-inline message_queue::message_queue(open_only_t open_only,
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(open_only_t open_only,
const char *name)
//Create shared memory and execute functor atomically
: m_shmem(open_only,
@@ -419,19 +456,22 @@
read_write,
static_cast<void*>(0),
//Prepare initialization functor
- detail::initialization_func_t ())
+ detail::initialization_func_t<VoidPointer> ())
{}
-inline void message_queue::send
- (const void *buffer, std::size_t buffer_size, unsigned int priority)
+template<class VoidPointer>
+inline void message_queue_t<VoidPointer>::send
+ (const void *buffer, size_type buffer_size, unsigned int priority)
{ this->do_send(blocking, buffer, buffer_size, priority, ptime()); }
-inline bool message_queue::try_send
- (const void *buffer, std::size_t buffer_size, unsigned int priority)
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::try_send
+ (const void *buffer, size_type buffer_size, unsigned int priority)
{ return this->do_send(non_blocking, buffer, buffer_size, priority, ptime()); }
-inline bool message_queue::timed_send
- (const void *buffer, std::size_t buffer_size
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::timed_send
+ (const void *buffer, size_type buffer_size
,unsigned int priority, const boost::posix_time::ptime &abs_time)
{
if(abs_time == boost::posix_time::pos_infin){
@@ -441,11 +481,12 @@
return this->do_send(timed, buffer, buffer_size, priority, abs_time);
}
-inline bool message_queue::do_send(block_t block,
- const void *buffer, std::size_t buffer_size,
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::do_send(block_t block,
+ const void *buffer, size_type buffer_size,
unsigned int priority, const boost::posix_time::ptime &abs_time)
{
- detail::mq_hdr_t *p_hdr = static_cast<detail::mq_hdr_t*>(m_shmem.get_user_address());
+ detail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<detail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
//Check if buffer is smaller than maximum allowed
if (buffer_size > p_hdr->m_max_msg_size) {
throw interprocess_exception(size_error);
@@ -486,7 +527,7 @@
}
//Get the first free message from free message queue
- detail::msg_hdr_t *free_msg = p_hdr->free_msg();
+ detail::msg_hdr_t<VoidPointer> *free_msg = p_hdr->free_msg();
if (free_msg == 0) {
throw interprocess_exception("boost::interprocess::message_queue corrupted");
}
@@ -511,18 +552,21 @@
return true;
}
-inline void message_queue::receive(void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size, unsigned int &priority)
+template<class VoidPointer>
+inline void message_queue_t<VoidPointer>::receive(void *buffer, size_type buffer_size,
+ size_type &recvd_size, unsigned int &priority)
{ this->do_receive(blocking, buffer, buffer_size, recvd_size, priority, ptime()); }
+template<class VoidPointer>
inline bool
- message_queue::try_receive(void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size, unsigned int &priority)
+ message_queue_t<VoidPointer>::try_receive(void *buffer, size_type buffer_size,
+ size_type &recvd_size, unsigned int &priority)
{ return this->do_receive(non_blocking, buffer, buffer_size, recvd_size, priority, ptime()); }
+template<class VoidPointer>
inline bool
- message_queue::timed_receive(void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size, unsigned int &priority,
+ message_queue_t<VoidPointer>::timed_receive(void *buffer, size_type buffer_size,
+ size_type &recvd_size, unsigned int &priority,
const boost::posix_time::ptime &abs_time)
{
if(abs_time == boost::posix_time::pos_infin){
@@ -532,13 +576,14 @@
return this->do_receive(timed, buffer, buffer_size, recvd_size, priority, abs_time);
}
+template<class VoidPointer>
inline bool
- message_queue::do_receive(block_t block,
- void *buffer, std::size_t buffer_size,
- std::size_t &recvd_size, unsigned int &priority,
+ message_queue_t<VoidPointer>::do_receive(block_t block,
+ void *buffer, size_type buffer_size,
+ size_type &recvd_size, unsigned int &priority,
const boost::posix_time::ptime &abs_time)
{
- detail::mq_hdr_t *p_hdr = static_cast<detail::mq_hdr_t*>(m_shmem.get_user_address());
+ detail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<detail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
//Check if buffer is big enough for any message
if (buffer_size < p_hdr->m_max_msg_size) {
throw interprocess_exception(size_error);
@@ -580,7 +625,7 @@
}
//Thre is at least message ready to pick, get the top one
- detail::msg_hdr_t *top_msg = p_hdr->top_msg();
+ detail::msg_hdr_t<VoidPointer> *top_msg = p_hdr->top_msg();
//Paranoia check
if (top_msg == 0) {
@@ -592,7 +637,7 @@
priority = top_msg->priority;
//Copy data to receiver's bufers
- std::memcpy(buffer, top_msg->data(), recvd_size);
+ std::memcpy(buffer, top_msg->data(), recvd_size);
// bool was_full = p_hdr->is_full();
@@ -608,20 +653,23 @@
return true;
}
-inline std::size_t message_queue::get_max_msg() const
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_max_msg() const
{
- detail::mq_hdr_t *p_hdr = static_cast<detail::mq_hdr_t*>(m_shmem.get_user_address());
+ detail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<detail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
return p_hdr ? p_hdr->m_max_num_msg : 0; }
-inline std::size_t message_queue::get_max_msg_size() const
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_max_msg_size() const
{
- detail::mq_hdr_t *p_hdr = static_cast<detail::mq_hdr_t*>(m_shmem.get_user_address());
+ detail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<detail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
return p_hdr ? p_hdr->m_max_msg_size : 0;
}
-inline std::size_t message_queue::get_num_msg()
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_num_msg()
{
- detail::mq_hdr_t *p_hdr = static_cast<detail::mq_hdr_t*>(m_shmem.get_user_address());
+ detail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<detail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
if(p_hdr){
//---------------------------------------------
scoped_lock<interprocess_mutex> lock(p_hdr->m_mutex);
@@ -632,7 +680,8 @@
return 0;
}
-inline bool message_queue::remove(const char *name)
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::remove(const char *name)
{ return shared_memory_object::remove(name); }
/// @endcond
Modified: trunk/boost/interprocess/managed_external_buffer.hpp
==============================================================================
--- trunk/boost/interprocess/managed_external_buffer.hpp (original)
+++ trunk/boost/interprocess/managed_external_buffer.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -43,10 +43,11 @@
/// @cond
typedef detail::basic_managed_memory_impl
<CharType, AllocationAlgorithm, IndexType> base_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_external_buffer)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_external_buffer)
/// @endcond
public:
+ typedef typename base_t::size_type size_type;
//!Default constructor. Does nothing.
//!Useful in combination with move semantics
@@ -55,10 +56,10 @@
//!Creates and places the segment manager. This can throw
basic_managed_external_buffer
- (create_only_t, void *addr, std::size_t size)
+ (create_only_t, void *addr, size_type size)
{
//Check if alignment is correct
- BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - std::size_t(1u)))));
+ BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - size_type(1u)))));
if(!base_t::create_impl(addr, size)){
throw interprocess_exception("Could not initialize buffer in basic_managed_external_buffer constructor");
}
@@ -66,30 +67,30 @@
//!Creates and places the segment manager. This can throw
basic_managed_external_buffer
- (open_only_t, void *addr, std::size_t size)
+ (open_only_t, void *addr, size_type size)
{
//Check if alignment is correct
- BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - std::size_t(1u)))));
+ BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - size_type(1u)))));
if(!base_t::open_impl(addr, size)){
throw interprocess_exception("Could not initialize buffer in basic_managed_external_buffer constructor");
}
}
//!Moves the ownership of "moved"'s managed memory to *this. Does not throw
- basic_managed_external_buffer(BOOST_INTERPROCESS_RV_REF(basic_managed_external_buffer) moved)
+ basic_managed_external_buffer(BOOST_RV_REF(basic_managed_external_buffer) moved)
{
this->swap(moved);
}
//!Moves the ownership of "moved"'s managed memory to *this. Does not throw
- basic_managed_external_buffer &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_external_buffer) moved)
+ basic_managed_external_buffer &operator=(BOOST_RV_REF(basic_managed_external_buffer) moved)
{
basic_managed_external_buffer tmp(boost::interprocess::move(moved));
this->swap(tmp);
return *this;
}
- void grow(std::size_t extra_bytes)
+ void grow(size_type extra_bytes)
{ base_t::grow(extra_bytes); }
//!Swaps the ownership of the managed heap memories managed by *this and other.
Modified: trunk/boost/interprocess/managed_heap_memory.hpp
==============================================================================
--- trunk/boost/interprocess/managed_heap_memory.hpp (original)
+++ trunk/boost/interprocess/managed_heap_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -46,10 +46,11 @@
typedef detail::basic_managed_memory_impl
<CharType, AllocationAlgorithm, IndexType> base_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_heap_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_heap_memory)
/// @endcond
public: //functions
+ typedef typename base_t::size_type size_type;
//!Default constructor. Does nothing.
//!Useful in combination with move semantics
@@ -62,7 +63,7 @@
//!Creates heap memory and initializes the segment manager.
//!This can throw.
- basic_managed_heap_memory(std::size_t size)
+ basic_managed_heap_memory(size_type size)
: m_heapmem(size, char(0))
{
if(!base_t::create_impl(&m_heapmem[0], size)){
@@ -72,11 +73,11 @@
}
//!Moves the ownership of "moved"'s managed memory to *this. Does not throw
- basic_managed_heap_memory(BOOST_INTERPROCESS_RV_REF(basic_managed_heap_memory) moved)
+ basic_managed_heap_memory(BOOST_RV_REF(basic_managed_heap_memory) moved)
{ this->swap(moved); }
//!Moves the ownership of "moved"'s managed memory to *this. Does not throw
- basic_managed_heap_memory &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_heap_memory) moved)
+ basic_managed_heap_memory &operator=(BOOST_RV_REF(basic_managed_heap_memory) moved)
{
basic_managed_heap_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
@@ -92,12 +93,12 @@
//!Returns true if the growth has been successful, so you will
//!have some extra bytes to allocate new objects. If returns
//!false, the heap allocation has failed.
- bool grow(std::size_t extra_bytes)
+ bool grow(size_type extra_bytes)
{
//If memory is reallocated, data will
//be automatically copied
BOOST_TRY{
- m_heapmem.resize(m_heapmem.size()+extra_bytes);
+ m_heapmem.resize(m_heapmem.size()+extra_bytes);
}
BOOST_CATCH(...){
return false;
Modified: trunk/boost/interprocess/managed_mapped_file.hpp
==============================================================================
--- trunk/boost/interprocess/managed_mapped_file.hpp (original)
+++ trunk/boost/interprocess/managed_mapped_file.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -48,6 +48,7 @@
<CharType, AllocationAlgorithm, IndexType,
detail::managed_open_or_create_impl<detail::file_wrapper>::ManagedOpenOrCreateUserOffset> base_t;
typedef detail::file_wrapper device_type;
+ typedef typename base_t::size_type size_type;
private:
@@ -59,7 +60,7 @@
private:
typedef typename base_t::char_ptr_holder_t char_ptr_holder_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_mapped_file)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_mapped_file)
/// @endcond
public: //functions
@@ -72,7 +73,7 @@
//!Creates mapped file and creates and places the segment manager.
//!This can throw.
basic_managed_mapped_file(create_only_t create_only, const char *name,
- std::size_t size, const void *addr = 0, const permissions &perm = permissions())
+ size_type size, const void *addr = 0, const permissions &perm = permissions())
: m_mfile(create_only, name, size, read_write, addr,
create_open_func_t(get_this_pointer(), detail::DoCreate), perm)
{}
@@ -82,7 +83,7 @@
//!segment.
//!This can throw.
basic_managed_mapped_file (open_or_create_t open_or_create,
- const char *name, std::size_t size,
+ const char *name, size_type size,
const void *addr = 0, const permissions &perm = permissions())
: m_mfile(open_or_create, name, size, read_write, addr,
create_open_func_t(get_this_pointer(),
@@ -120,14 +121,14 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_mapped_file(BOOST_INTERPROCESS_RV_REF(basic_managed_mapped_file) moved)
+ basic_managed_mapped_file(BOOST_RV_REF(basic_managed_mapped_file) moved)
{
this->swap(moved);
}
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_mapped_file &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_mapped_file) moved)
+ basic_managed_mapped_file &operator=(BOOST_RV_REF(basic_managed_mapped_file) moved)
{
basic_managed_mapped_file tmp(boost::interprocess::move(moved));
this->swap(tmp);
@@ -161,7 +162,7 @@
//!
//!This function is not synchronized so no other thread or process should
//!be reading or writing the file
- static bool grow(const char *filename, std::size_t extra_bytes)
+ static bool grow(const char *filename, size_type extra_bytes)
{
return base_t::template grow
<basic_managed_mapped_file>(filename, extra_bytes);
@@ -183,7 +184,7 @@
//!buffer and the object count. If not found returned pointer is 0.
//!Never throws.
template <class T>
- std::pair<T*, std::size_t> find (char_ptr_holder_t name)
+ std::pair<T*, size_type> find (char_ptr_holder_t name)
{
if(m_mfile.get_mapped_region().get_mode() == read_only){
return base_t::template find_no_lock<T>(name);
Modified: trunk/boost/interprocess/managed_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/managed_shared_memory.hpp (original)
+++ trunk/boost/interprocess/managed_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -45,10 +45,6 @@
, private detail::managed_open_or_create_impl<shared_memory_object>
{
/// @cond
- public:
- typedef shared_memory_object device_type;
-
- private:
typedef detail::basic_managed_memory_impl
<CharType, AllocationAlgorithm, IndexType,
detail::managed_open_or_create_impl<shared_memory_object>::ManagedOpenOrCreateUserOffset> base_t;
@@ -60,9 +56,13 @@
basic_managed_shared_memory *get_this_pointer()
{ return this; }
+ public:
+ typedef shared_memory_object device_type;
+ typedef typename base_t::size_type size_type;
+
private:
typedef typename base_t::char_ptr_holder_t char_ptr_holder_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_shared_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_shared_memory)
/// @endcond
public: //functions
@@ -84,7 +84,7 @@
//!Creates shared memory and creates and places the segment manager.
//!This can throw.
basic_managed_shared_memory(create_only_t create_only, const char *name,
- std::size_t size, const void *addr = 0, const permissions& perm = permissions())
+ size_type size, const void *addr = 0, const permissions& perm = permissions())
: base_t()
, base2_t(create_only, name, size, read_write, addr,
create_open_func_t(get_this_pointer(), detail::DoCreate), perm)
@@ -95,7 +95,7 @@
//!segment.
//!This can throw.
basic_managed_shared_memory (open_or_create_t open_or_create,
- const char *name, std::size_t size,
+ const char *name, size_type size,
const void *addr = 0, const permissions& perm = permissions())
: base_t()
, base2_t(open_or_create, name, size, read_write, addr,
@@ -137,7 +137,7 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_shared_memory(BOOST_INTERPROCESS_RV_REF(basic_managed_shared_memory) moved)
+ basic_managed_shared_memory(BOOST_RV_REF(basic_managed_shared_memory) moved)
{
basic_managed_shared_memory tmp;
this->swap(moved);
@@ -146,7 +146,7 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_shared_memory) moved)
+ basic_managed_shared_memory &operator=(BOOST_RV_REF(basic_managed_shared_memory) moved)
{
basic_managed_shared_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
@@ -166,7 +166,7 @@
//!
//!This function is not synchronized so no other thread or process should
//!be reading or writing the file
- static bool grow(const char *shmname, std::size_t extra_bytes)
+ static bool grow(const char *shmname, size_type extra_bytes)
{
return base_t::template grow
<basic_managed_shared_memory>(shmname, extra_bytes);
@@ -193,7 +193,7 @@
//!buffer and the object count. If not found returned pointer is 0.
//!Never throws.
template <class T>
- std::pair<T*, std::size_t> find (char_ptr_holder_t name)
+ std::pair<T*, size_type> find (char_ptr_holder_t name)
{
if(base2_t::get_mapped_region().get_mode() == read_only){
return base_t::template find_no_lock<T>(name);
Modified: trunk/boost/interprocess/managed_windows_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/managed_windows_shared_memory.hpp (original)
+++ trunk/boost/interprocess/managed_windows_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -61,10 +61,11 @@
private:
typedef typename base_t::char_ptr_holder_t char_ptr_holder_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_windows_shared_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_windows_shared_memory)
/// @endcond
public: //functions
+ typedef typename base_t::size_type size_type;
//!Default constructor. Does nothing.
//!Useful in combination with move semantics
@@ -75,7 +76,7 @@
//!This can throw.
basic_managed_windows_shared_memory
(create_only_t create_only, const char *name,
- std::size_t size, const void *addr = 0, const permissions &perm = permissions())
+ size_type size, const void *addr = 0, const permissions &perm = permissions())
: m_wshm(create_only, name, size, read_write, addr,
create_open_func_t(get_this_pointer(), detail::DoCreate), perm)
{}
@@ -86,7 +87,7 @@
//!This can throw.
basic_managed_windows_shared_memory
(open_or_create_t open_or_create,
- const char *name, std::size_t size,
+ const char *name, size_type size,
const void *addr = 0,
const permissions &perm = permissions())
: m_wshm(open_or_create, name, size, read_write, addr,
@@ -125,12 +126,12 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
basic_managed_windows_shared_memory
- (BOOST_INTERPROCESS_RV_REF(basic_managed_windows_shared_memory) moved)
+ (BOOST_RV_REF(basic_managed_windows_shared_memory) moved)
{ this->swap(moved); }
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_windows_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_windows_shared_memory) moved)
+ basic_managed_windows_shared_memory &operator=(BOOST_RV_REF(basic_managed_windows_shared_memory) moved)
{
basic_managed_windows_shared_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
@@ -159,7 +160,7 @@
//!buffer and the object count. If not found returned pointer is 0.
//!Never throws.
template <class T>
- std::pair<T*, std::size_t> find (char_ptr_holder_t name)
+ std::pair<T*, size_type> find (char_ptr_holder_t name)
{
if(m_wshm.get_mapped_region().get_mode() == read_only){
return base_t::template find_no_lock<T>(name);
Modified: trunk/boost/interprocess/managed_xsi_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/managed_xsi_shared_memory.hpp (original)
+++ trunk/boost/interprocess/managed_xsi_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -64,10 +64,11 @@
private:
typedef typename base_t::char_ptr_holder_t char_ptr_holder_t;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_xsi_shared_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_xsi_shared_memory)
/// @endcond
public: //functions
+ typedef typename base_t::size_type size_type;
//!Destroys *this and indicates that the calling process is finished using
//!the resource. The destructor function will deallocate
@@ -128,7 +129,7 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_xsi_shared_memory(BOOST_INTERPROCESS_RV_REF(basic_managed_xsi_shared_memory) moved)
+ basic_managed_xsi_shared_memory(BOOST_RV_REF(basic_managed_xsi_shared_memory) moved)
{
basic_managed_xsi_shared_memory tmp;
this->swap(moved);
@@ -137,7 +138,7 @@
//!Moves the ownership of "moved"'s managed memory to *this.
//!Does not throw
- basic_managed_xsi_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_xsi_shared_memory) moved)
+ basic_managed_xsi_shared_memory &operator=(BOOST_RV_REF(basic_managed_xsi_shared_memory) moved)
{
basic_managed_xsi_shared_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/mapped_region.hpp
==============================================================================
--- trunk/boost/interprocess/mapped_region.hpp (original)
+++ trunk/boost/interprocess/mapped_region.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -59,7 +59,7 @@
{
/// @cond
//Non-copyable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(mapped_region)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(mapped_region)
/// @endcond
public:
@@ -81,7 +81,7 @@
//!Move constructor. *this will be constructed taking ownership of "other"'s
//!region and "other" will be left in default constructor state.
- mapped_region(BOOST_INTERPROCESS_RV_REF(mapped_region) other)
+ mapped_region(BOOST_RV_REF(mapped_region) other)
#if defined (BOOST_INTERPROCESS_WINDOWS)
: m_base(0), m_size(0), m_offset(0)
, m_extra_offset(0)
@@ -99,7 +99,7 @@
//!Move assignment. If *this owns a memory mapped region, it will be
//!destroyed and it will take ownership of "other"'s memory mapped region.
- mapped_region &operator=(BOOST_INTERPROCESS_RV_REF(mapped_region) other)
+ mapped_region &operator=(BOOST_RV_REF(mapped_region) other)
{
mapped_region tmp(boost::interprocess::move(other));
this->swap(tmp);
Modified: trunk/boost/interprocess/mem_algo/detail/mem_algo_common.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/detail/mem_algo_common.hpp (original)
+++ trunk/boost/interprocess/mem_algo/detail/mem_algo_common.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -50,19 +50,20 @@
typedef typename MemoryAlgorithm::block_ctrl block_ctrl;
typedef typename MemoryAlgorithm::multiallocation_chain multiallocation_chain;
typedef memory_algorithm_common<MemoryAlgorithm> this_type;
+ typedef typename MemoryAlgorithm::size_type size_type;
- static const std::size_t Alignment = MemoryAlgorithm::Alignment;
- static const std::size_t MinBlockUnits = MemoryAlgorithm::MinBlockUnits;
- static const std::size_t AllocatedCtrlBytes = MemoryAlgorithm::AllocatedCtrlBytes;
- static const std::size_t AllocatedCtrlUnits = MemoryAlgorithm::AllocatedCtrlUnits;
- static const std::size_t BlockCtrlBytes = MemoryAlgorithm::BlockCtrlBytes;
- static const std::size_t BlockCtrlUnits = MemoryAlgorithm::BlockCtrlUnits;
- static const std::size_t UsableByPreviousChunk = MemoryAlgorithm::UsableByPreviousChunk;
+ static const size_type Alignment = MemoryAlgorithm::Alignment;
+ static const size_type MinBlockUnits = MemoryAlgorithm::MinBlockUnits;
+ static const size_type AllocatedCtrlBytes = MemoryAlgorithm::AllocatedCtrlBytes;
+ static const size_type AllocatedCtrlUnits = MemoryAlgorithm::AllocatedCtrlUnits;
+ static const size_type BlockCtrlBytes = MemoryAlgorithm::BlockCtrlBytes;
+ static const size_type BlockCtrlUnits = MemoryAlgorithm::BlockCtrlUnits;
+ static const size_type UsableByPreviousChunk = MemoryAlgorithm::UsableByPreviousChunk;
static void assert_alignment(const void *ptr)
{ assert_alignment((std::size_t)ptr); }
- static void assert_alignment(std::size_t uint_ptr)
+ static void assert_alignment(size_type uint_ptr)
{
(void)uint_ptr;
BOOST_ASSERT(uint_ptr % Alignment == 0);
@@ -71,17 +72,17 @@
static bool check_alignment(const void *ptr)
{ return (((std::size_t)ptr) % Alignment == 0); }
- static std::size_t ceil_units(std::size_t size)
+ static size_type ceil_units(size_type size)
{ return detail::get_rounded_size(size, Alignment)/Alignment; }
- static std::size_t floor_units(std::size_t size)
+ static size_type floor_units(size_type size)
{ return size/Alignment; }
- static std::size_t multiple_of_units(std::size_t size)
+ static size_type multiple_of_units(size_type size)
{ return detail::get_rounded_size(size, Alignment); }
static multiallocation_chain allocate_many
- (MemoryAlgorithm *memory_algo, std::size_t elem_bytes, std::size_t n_elements)
+ (MemoryAlgorithm *memory_algo, size_type elem_bytes, size_type n_elements)
{
return this_type::priv_allocate_many(memory_algo, &elem_bytes, n_elements, 0);
}
@@ -92,19 +93,19 @@
}
static bool calculate_lcm_and_needs_backwards_lcmed
- (std::size_t backwards_multiple, std::size_t received_size, std::size_t size_to_achieve,
- std::size_t &lcm_out, std::size_t &needs_backwards_lcmed_out)
+ (size_type backwards_multiple, size_type received_size, size_type size_to_achieve,
+ size_type &lcm_out, size_type &needs_backwards_lcmed_out)
{
// Now calculate lcm
- std::size_t max = backwards_multiple;
- std::size_t min = Alignment;
- std::size_t needs_backwards;
- std::size_t needs_backwards_lcmed;
- std::size_t lcm;
- std::size_t current_forward;
+ size_type max = backwards_multiple;
+ size_type min = Alignment;
+ size_type needs_backwards;
+ size_type needs_backwards_lcmed;
+ size_type lcm;
+ size_type current_forward;
//Swap if necessary
if(max < min){
- std::size_t tmp = min;
+ size_type tmp = min;
min = max;
max = tmp;
}
@@ -152,7 +153,7 @@
}
//Check if it's multiple of the half of the alignmment
else if((backwards_multiple & ((Alignment/4u) - 1u)) == 0){
- std::size_t remainder;
+ size_type remainder;
lcm = backwards_multiple*4u;
current_forward = detail::get_truncated_size(received_size, backwards_multiple);
needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
@@ -188,25 +189,25 @@
static multiallocation_chain allocate_many
( MemoryAlgorithm *memory_algo
- , const std::size_t *elem_sizes
- , std::size_t n_elements
- , std::size_t sizeof_element)
+ , const size_type *elem_sizes
+ , size_type n_elements
+ , size_type sizeof_element)
{
return this_type::priv_allocate_many(memory_algo, elem_sizes, n_elements, sizeof_element);
}
static void* allocate_aligned
- (MemoryAlgorithm *memory_algo, std::size_t nbytes, std::size_t alignment)
+ (MemoryAlgorithm *memory_algo, size_type nbytes, size_type alignment)
{
//Ensure power of 2
- if ((alignment & (alignment - std::size_t(1u))) != 0){
+ if ((alignment & (alignment - size_type(1u))) != 0){
//Alignment is not power of two
- BOOST_ASSERT((alignment & (alignment - std::size_t(1u))) == 0);
+ BOOST_ASSERT((alignment & (alignment - size_type(1u))) == 0);
return 0;
}
- std::size_t real_size;
+ size_type real_size;
if(alignment <= Alignment){
return memory_algo->priv_allocate
(boost::interprocess::allocate_new, nbytes, nbytes, real_size).first;
@@ -217,8 +218,8 @@
//We can find a aligned portion if we allocate a block that has alignment
//nbytes + alignment bytes or more.
- std::size_t minimum_allocation = max_value
- (nbytes + alignment, std::size_t(MinBlockUnits*Alignment));
+ size_type minimum_allocation = max_value
+ (nbytes + alignment, size_type(MinBlockUnits*Alignment));
//Since we will split that block, we must request a bit more memory
//if the alignment is near the beginning of the buffer, because otherwise,
//there is no space for a new block before the alignment.
@@ -228,7 +229,7 @@
// -----------------------------------------------------
// | MBU |
// -----------------------------------------------------
- std::size_t request =
+ size_type request =
minimum_allocation + (2*MinBlockUnits*Alignment - AllocatedCtrlBytes
//prevsize - UsableByPreviousChunk
);
@@ -243,9 +244,9 @@
//If we are lucky and the buffer is aligned, just split it and
//return the high part
block_ctrl *first = memory_algo->priv_get_block(buffer);
- std::size_t old_size = first->m_size;
- const std::size_t first_min_units =
- max_value(ceil_units(nbytes) + AllocatedCtrlUnits, std::size_t(MinBlockUnits));
+ size_type old_size = first->m_size;
+ const size_type first_min_units =
+ max_value(ceil_units(nbytes) + AllocatedCtrlUnits, size_type(MinBlockUnits));
//We can create a new block in the end of the segment
if(old_size >= (first_min_units + MinBlockUnits)){
block_ctrl *second = reinterpret_cast<block_ctrl *>
@@ -285,8 +286,8 @@
BOOST_ASSERT((pos + MinBlockUnits*Alignment - AllocatedCtrlBytes + nbytes*Alignment/Alignment) <=
(reinterpret_cast<char*>(first) + first->m_size*Alignment));
//Set the new size of the first block
- std::size_t old_size = first->m_size;
- first->m_size = (reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
+ size_type old_size = first->m_size;
+ first->m_size = (size_type)(reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
memory_algo->priv_mark_new_allocated_block(first);
//Now check if we can create a new buffer in the end
@@ -299,7 +300,7 @@
// -----------------------------------------------------
//This size will be the minimum size to be able to create a
//new block in the end.
- const std::size_t second_min_units = max_value(std::size_t(MinBlockUnits),
+ const size_type second_min_units = max_value(size_type(MinBlockUnits),
ceil_units(nbytes) + AllocatedCtrlUnits );
//Check if we can create a new block (of size MinBlockUnits) in the end of the segment
@@ -325,13 +326,13 @@
static bool try_shrink
(MemoryAlgorithm *memory_algo, void *ptr
- ,const std::size_t max_size, const std::size_t preferred_size
- ,std::size_t &received_size)
+ ,const size_type max_size, const size_type preferred_size
+ ,size_type &received_size)
{
(void)memory_algo;
//Obtain the real block
block_ctrl *block = memory_algo->priv_get_block(ptr);
- std::size_t old_block_units = block->m_size;
+ size_type old_block_units = (size_type)block->m_size;
//The block must be marked as allocated
BOOST_ASSERT(memory_algo->priv_is_allocated_block(block));
@@ -343,15 +344,15 @@
received_size = (old_block_units - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
//Now translate it to Alignment units
- const std::size_t max_user_units = floor_units(max_size - UsableByPreviousChunk);
- const std::size_t preferred_user_units = ceil_units(preferred_size - UsableByPreviousChunk);
+ const size_type max_user_units = floor_units(max_size - UsableByPreviousChunk);
+ const size_type preferred_user_units = ceil_units(preferred_size - UsableByPreviousChunk);
//Check if rounded max and preferred are possible correct
if(max_user_units < preferred_user_units)
return false;
//Check if the block is smaller than the requested minimum
- std::size_t old_user_units = old_block_units - AllocatedCtrlUnits;
+ size_type old_user_units = old_block_units - AllocatedCtrlUnits;
if(old_user_units < preferred_user_units)
return false;
@@ -360,7 +361,7 @@
if(old_user_units == preferred_user_units)
return true;
- std::size_t shrunk_user_units =
+ size_type shrunk_user_units =
((BlockCtrlUnits - AllocatedCtrlUnits) > preferred_user_units)
? (BlockCtrlUnits - AllocatedCtrlUnits)
: preferred_user_units;
@@ -381,12 +382,12 @@
static bool shrink
(MemoryAlgorithm *memory_algo, void *ptr
- ,const std::size_t max_size, const std::size_t preferred_size
- ,std::size_t &received_size)
+ ,const size_type max_size, const size_type preferred_size
+ ,size_type &received_size)
{
//Obtain the real block
block_ctrl *block = memory_algo->priv_get_block(ptr);
- std::size_t old_block_units = block->m_size;
+ size_type old_block_units = (size_type)block->m_size;
if(!try_shrink
(memory_algo, ptr, max_size, preferred_size, received_size)){
@@ -417,24 +418,24 @@
private:
static multiallocation_chain priv_allocate_many
( MemoryAlgorithm *memory_algo
- , const std::size_t *elem_sizes
- , std::size_t n_elements
- , std::size_t sizeof_element)
+ , const size_type *elem_sizes
+ , size_type n_elements
+ , size_type sizeof_element)
{
//Note: sizeof_element == 0 indicates that we want to
//allocate n_elements of the same size "*elem_sizes"
//Calculate the total size of all requests
- std::size_t total_request_units = 0;
- std::size_t elem_units = 0;
- const std::size_t ptr_size_units = memory_algo->priv_get_total_units(sizeof(void_pointer));
+ size_type total_request_units = 0;
+ size_type elem_units = 0;
+ const size_type ptr_size_units = memory_algo->priv_get_total_units(sizeof(void_pointer));
if(!sizeof_element){
elem_units = memory_algo->priv_get_total_units(*elem_sizes);
elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
total_request_units = n_elements*elem_units;
}
else{
- for(std::size_t i = 0; i < n_elements; ++i){
+ for(size_type i = 0; i < n_elements; ++i){
elem_units = memory_algo->priv_get_total_units(elem_sizes[i]*sizeof_element);
elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
total_request_units += elem_units;
@@ -443,15 +444,15 @@
multiallocation_chain chain;
- std::size_t low_idx = 0;
+ size_type low_idx = 0;
while(low_idx < n_elements){
- std::size_t total_bytes = total_request_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
- std::size_t min_allocation = (!sizeof_element)
+ size_type total_bytes = total_request_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
+ size_type min_allocation = (!sizeof_element)
? elem_units
: memory_algo->priv_get_total_units(elem_sizes[low_idx]*sizeof_element);
min_allocation = min_allocation*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
- std::size_t received_size;
+ size_type received_size;
std::pair<void *, bool> ret = memory_algo->priv_allocate
(boost::interprocess::allocate_new, min_allocation, total_bytes, received_size, 0);
if(!ret.first){
@@ -459,10 +460,10 @@
}
block_ctrl *block = memory_algo->priv_get_block(ret.first);
- std::size_t received_units = block->m_size;
+ size_type received_units = (size_type)block->m_size;
char *block_address = reinterpret_cast<char*>(block);
- std::size_t total_used_units = 0;
+ size_type total_used_units = 0;
// block_ctrl *prev_block = 0;
while(total_used_units < received_units){
if(sizeof_element){
@@ -481,7 +482,7 @@
(total_used_units + elem_units +
((!sizeof_element)
? elem_units
- : memory_algo->priv_get_total_units(elem_sizes[low_idx+1]*sizeof_element))
+ : std::max(memory_algo->priv_get_total_units(elem_sizes[low_idx+1]*sizeof_element), ptr_size_units))
) > received_units){
//By default, the new block will use the rest of the buffer
new_block->m_size = received_units - total_used_units;
@@ -490,8 +491,8 @@
//If the remaining units are bigger than needed and we can
//split it obtaining a new free memory block do it.
if((received_units - total_used_units) >= (elem_units + MemoryAlgorithm::BlockCtrlUnits)){
- std::size_t shrunk_received;
- std::size_t shrunk_request = elem_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
+ size_type shrunk_received;
+ size_type shrunk_request = elem_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
bool shrink_ok = shrink
(memory_algo
,memory_algo->priv_get_user_buffer(new_block)
@@ -516,7 +517,7 @@
}
block_address += new_block->m_size*Alignment;
- total_used_units += new_block->m_size;
+ total_used_units += (size_type)new_block->m_size;
//Check we have enough room to overwrite the intrusive pointer
BOOST_ASSERT((new_block->m_size*Alignment - AllocatedCtrlUnits) >= sizeof(void_pointer));
void_pointer p = new(memory_algo->priv_get_user_buffer(new_block))void_pointer(0);
Modified: trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp (original)
+++ trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -41,13 +41,13 @@
/*!Constructor. "size" is the total size of the managed memory segment,
"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(multi_simple_seq_fit)
offset that the allocator should not use at all.*/
- multi_simple_seq_fit (std::size_t size, std::size_t extra_hdr_bytes)
+ multi_simple_seq_fit (size_type size, size_type extra_hdr_bytes)
: base_t(size, extra_hdr_bytes){}
/*!Allocates bytes from existing segments. If there is no memory, it uses
the growing functor associated with the group to allocate a new segment.
If this fails, returns 0.*/
- void* allocate (std::size_t nbytes)
+ void* allocate (size_type nbytes)
{ return base_t::multi_allocate(nbytes); }
};
Modified: trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp (original)
+++ trunk/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -68,6 +68,10 @@
/*!Pointer type to be used with the rest of the Interprocess framework*/
typedef VoidPointer void_pointer;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+
+
private:
struct block_ctrl;
typedef typename boost::
@@ -80,12 +84,12 @@
block_ctrl_ptr m_next;
/*!This block's memory size (including block_ctrl
header) in BasicSize units*/
- std::size_t m_size;
+ size_type m_size;
- std::size_t get_user_bytes() const
+ size_type get_user_bytes() const
{ return this->m_size*Alignment - BlockCtrlBytes; }
- std::size_t get_total_bytes() const
+ size_type get_total_bytes() const
{ return this->m_size*Alignment; }
static block_ctrl *get_block_from_addr(void *addr)
@@ -112,34 +116,34 @@
/*!Pointer to the first free block*/
block_ctrl m_root;
/*!Allocated bytes for internal checking*/
- std::size_t m_allocated;
+ size_type m_allocated;
/*!The size of the memory segment*/
- std::size_t m_size;
+ size_type m_size;
} m_header;
public:
/*!Constructor. "size" is the total size of the managed memory segment,
"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit_impl)
offset that the allocator should not use at all.*/
- simple_seq_fit_impl (std::size_t size, std::size_t extra_hdr_bytes);
+ simple_seq_fit_impl (size_type size, size_type extra_hdr_bytes);
/*!Destructor.*/
~simple_seq_fit_impl();
/*!Obtains the minimum size needed by the algorithm*/
- static std::size_t get_min_size (std::size_t extra_hdr_bytes);
+ static size_type get_min_size (size_type extra_hdr_bytes);
//Functions for single segment management
/*!Allocates bytes, returns 0 if there is not more memory*/
- void* allocate (std::size_t nbytes);
+ void* allocate (size_type nbytes);
/*!Deallocates previously allocated bytes*/
void deallocate (void *addr);
/*!Returns the size of the memory segment*/
- std::size_t get_size() const;
+ size_type get_size() const;
/*!Increases managed memory in extra_size bytes more*/
- void grow(std::size_t extra_size);
+ void grow(size_type extra_size);
/*!Returns true if all allocated memory has been deallocated*/
bool all_memory_deallocated();
@@ -152,30 +156,30 @@
void clear_free_memory();
std::pair<void *, bool>
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
- void *reuse_ptr = 0, std::size_t backwards_multiple = 1);
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
+ void *reuse_ptr = 0, size_type backwards_multiple = 1);
/*!Returns the size of the buffer previously allocated pointed by ptr*/
- std::size_t size(void *ptr) const;
+ size_type size(void *ptr) const;
/*!Allocates aligned bytes, returns 0 if there is not more memory.
Alignment must be power of 2*/
- void* allocate_aligned (std::size_t nbytes, std::size_t alignment);
+ void* allocate_aligned (size_type nbytes, size_type alignment);
/*!Allocates bytes, if there is no more memory, it executes functor
- f(std::size_t) to allocate a new segment to manage. The functor returns
- std::pair<void*, std::size_t> indicating the base address and size of
+ f(size_type) to allocate a new segment to manage. The functor returns
+ std::pair<void*, size_type> indicating the base address and size of
the new segment. If the new segment can't be allocated, allocate
it will return 0.*/
- void* multi_allocate(std::size_t nbytes);
+ void* multi_allocate(size_type nbytes);
private:
/*!Real allocation algorithm with min allocation option*/
std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr = 0);
/*!Returns next block if it's free.
Returns 0 if next block is not free.*/
@@ -187,38 +191,38 @@
/*!Real expand function implementation*/
bool priv_expand(void *ptr
- ,std::size_t min_size, std::size_t preferred_size
- ,std::size_t &received_size);
+ ,size_type min_size, size_type preferred_size
+ ,size_type &received_size);
/*!Real expand to both sides implementation*/
void* priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards);
/*!Real shrink function implementation*/
bool priv_shrink(void *ptr
- ,std::size_t max_size, std::size_t preferred_size
- ,std::size_t &received_size);
+ ,size_type max_size, size_type preferred_size
+ ,size_type &received_size);
//!Real private aligned allocation function
- void* priv_allocate_aligned (std::size_t nbytes, std::size_t alignment);
+ void* priv_allocate_aligned (size_type nbytes, size_type alignment);
/*!Checks if block has enough memory and splits/unlinks the block
returning the address to the users*/
- void* priv_check_and_allocate(std::size_t units
+ void* priv_check_and_allocate(size_type units
,block_ctrl* prev
,block_ctrl* block
- ,std::size_t &received_size);
+ ,size_type &received_size);
/*!Real deallocation algorithm*/
void priv_deallocate(void *addr);
/*!Makes a new memory portion available for allocation*/
- void priv_add_segment(void *addr, std::size_t size);
+ void priv_add_segment(void *addr, size_type size);
- enum { Alignment = boost::alignment_of<boost::detail::max_align>::value };
+ enum { Alignment = ::boost::alignment_of<boost::detail::max_align>::value };
enum { BlockCtrlBytes = detail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value };
enum { BlockCtrlSize = BlockCtrlBytes/Alignment };
enum { MinBlockSize = BlockCtrlSize + Alignment };
@@ -229,14 +233,14 @@
template<class MutexFamily, class VoidPointer>
inline simple_seq_fit_impl<MutexFamily, VoidPointer>::
- simple_seq_fit_impl(std::size_t size, std::size_t extra_hdr_bytes)
+ simple_seq_fit_impl(size_type size, size_type extra_hdr_bytes)
{
//Initialize sizes and counters
m_header.m_allocated = 0;
m_header.m_size = size;
//Initialize pointers
- std::size_t block1_off = detail::get_rounded_size(sizeof(*this)+extra_hdr_bytes, Alignment);
+ size_type block1_off = detail::get_rounded_size(sizeof(*this)+extra_hdr_bytes, Alignment);
m_header.m_root.m_next = reinterpret_cast<block_ctrl*>
(reinterpret_cast<char*>(this) + block1_off);
m_header.m_root.m_next->m_size = (size - block1_off)/Alignment;
@@ -252,10 +256,10 @@
}
template<class MutexFamily, class VoidPointer>
-inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(std::size_t extra_size)
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(size_type extra_size)
{
//Old highest address block's end offset
- std::size_t old_end = m_header.m_size/Alignment*Alignment;
+ size_type old_end = m_header.m_size/Alignment*Alignment;
//Update managed buffer's size
m_header.m_size += extra_size;
@@ -276,7 +280,7 @@
}
template<class MutexFamily, class VoidPointer>
-inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, std::size_t size)
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, size_type size)
{
//Check size
BOOST_ASSERT(!(size < MinBlockSize));
@@ -293,12 +297,14 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size() const
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size() const
{ return m_header.m_size; }
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::
- get_min_size (std::size_t extra_hdr_bytes)
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+ get_min_size (size_type extra_hdr_bytes)
{
return detail::get_rounded_size(sizeof(simple_seq_fit_impl)+extra_hdr_bytes
,Alignment)
@@ -344,7 +350,7 @@
//-----------------------
block_ctrl *block = detail::get_pointer(m_header.m_root.m_next);
- std::size_t free_memory = 0;
+ size_type free_memory = 0;
//Iterate through all blocks obtaining their size
do{
@@ -372,18 +378,18 @@
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocate(std::size_t nbytes)
+ allocate(size_type nbytes)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
//-----------------------
- std::size_t ignore;
+ size_type ignore;
return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
}
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ allocate_aligned(size_type nbytes, size_type alignment)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -393,9 +399,9 @@
template<class MutexFamily, class VoidPointer>
inline std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocation_command (boost::interprocess::allocation_type command, std::size_t min_size,
- std::size_t preferred_size,std::size_t &received_size,
- void *reuse_ptr, std::size_t backwards_multiple)
+ allocation_command (boost::interprocess::allocation_type command, size_type min_size,
+ size_type preferred_size,size_type &received_size,
+ void *reuse_ptr, size_type backwards_multiple)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -408,7 +414,8 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
size(void *ptr) const
{
//We need no synchronization since this block is not going
@@ -421,19 +428,19 @@
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- multi_allocate(std::size_t nbytes)
+ multi_allocate(size_type nbytes)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
//-----------------------
//Multisegment pointer. Let's try first the normal allocation
//since it's faster.
- std::size_t ignore;
+ size_type ignore;
void *addr = this->priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
if(!addr){
//If this fails we will try the allocation through the segment
//creator.
- std::size_t group, id;
+ size_type group, id;
//Obtain the segment group of this segment
void_pointer::get_group_and_id(this, group, id);
if(group == 0){
@@ -446,7 +453,7 @@
static_cast<boost::interprocess::multi_segment_services*>
(void_pointer::find_group_data(group));
BOOST_ASSERT(p_services);
- std::pair<void *, std::size_t> ret =
+ std::pair<void *, std::size_t> ret =
p_services->create_new_segment(MinBlockSize > nbytes ? MinBlockSize : nbytes);
if(ret.first){
priv_add_segment(ret.first, ret.second);
@@ -459,9 +466,9 @@
template<class MutexFamily, class VoidPointer>
void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards)
{
@@ -482,14 +489,14 @@
received_size = this->size(reuse_ptr);
}
if(command & boost::interprocess::expand_bwd){
- std::size_t extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
+ size_type extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
prev_block_t prev_pair = priv_prev_block_if_free(reuse);
block_ctrl *prev = prev_pair.second;
if(!prev){
return 0;
}
- std::size_t needs_backwards =
+ size_type needs_backwards =
detail::get_rounded_size(preferred_size - extra_forward, Alignment);
if(!only_preferred_backwards){
@@ -538,9 +545,9 @@
template<class MutexFamily, class VoidPointer>
std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t limit_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type limit_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr)
{
if(command & boost::interprocess::shrink_in_place){
@@ -555,7 +562,7 @@
return return_type(0, false);
//Number of units to request (including block_ctrl header)
- std::size_t nunits = detail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlSize;
+ size_type nunits = detail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlSize;
//Get the root and the first memory block
block_ctrl *prev = &m_header.m_root;
@@ -563,7 +570,7 @@
block_ctrl *root = &m_header.m_root;
block_ctrl *biggest_block = 0;
block_ctrl *prev_biggest_block = 0;
- std::size_t biggest_size = limit_size;
+ size_type biggest_size = limit_size;
//Expand in place
//reuse_ptr, limit_size, preferred_size, received_size
@@ -621,7 +628,7 @@
(reinterpret_cast<char*>(ptr) + ptr->m_size*Alignment);
//Check if the adjacent block is in the managed segment
- std::size_t distance = (reinterpret_cast<char*>(next_block) - reinterpret_cast<char*>(this))/Alignment;
+ size_type distance = (reinterpret_cast<char*>(next_block) - reinterpret_cast<char*>(this))/Alignment;
if(distance >= (m_header.m_size/Alignment)){
//"next_block" does not exist so we can't expand "block"
return 0;
@@ -657,7 +664,7 @@
return prev_pair_t(0, 0);
//Check if the previous block is in the managed segment
- std::size_t distance = (reinterpret_cast<char*>(prev_block) - reinterpret_cast<char*>(this))/Alignment;
+ size_type distance = (reinterpret_cast<char*>(prev_block) - reinterpret_cast<char*>(this))/Alignment;
if(distance >= (m_header.m_size/Alignment)){
//"previous_block" does not exist so we can't expand "block"
return prev_pair_t(0, 0);
@@ -669,14 +676,14 @@
template<class MutexFamily, class VoidPointer>
inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_expand (void *ptr
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size)
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size)
{
//Obtain the real size of the block
block_ctrl *block = reinterpret_cast<block_ctrl*>
(reinterpret_cast<char*>(ptr) - BlockCtrlBytes);
- std::size_t old_block_size = block->m_size;
+ size_type old_block_size = block->m_size;
//All used blocks' next is marked with 0 so check it
BOOST_ASSERT(block->m_next == 0);
@@ -692,7 +699,7 @@
if(min_size > preferred_size)
return false;
- std::size_t data_size = old_block_size - BlockCtrlSize;
+ size_type data_size = old_block_size - BlockCtrlSize;
if(data_size >= min_size)
return true;
@@ -703,7 +710,7 @@
}
//Is "block" + "next_block" big enough?
- std::size_t merged_size = old_block_size + next_block->m_size;
+ size_type merged_size = old_block_size + next_block->m_size;
//Now we can expand this block further than before
received_size = merged_size*Alignment - BlockCtrlBytes;
@@ -729,7 +736,7 @@
//Now use check and allocate to do the allocation logic
preferred_size += BlockCtrlSize;
- std::size_t nunits = preferred_size < merged_size ? preferred_size : merged_size;
+ size_type nunits = preferred_size < merged_size ? preferred_size : merged_size;
//This must success since nunits is less than merged_size!
if(!this->priv_check_and_allocate (nunits, prev, block, received_size)){
@@ -744,14 +751,14 @@
template<class MutexFamily, class VoidPointer>
inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_shrink (void *ptr
- ,std::size_t max_size
- ,std::size_t preferred_size
- ,std::size_t &received_size)
+ ,size_type max_size
+ ,size_type preferred_size
+ ,size_type &received_size)
{
//Obtain the real size of the block
block_ctrl *block = reinterpret_cast<block_ctrl*>
(reinterpret_cast<char*>(ptr) - BlockCtrlBytes);
- std::size_t block_size = block->m_size;
+ size_type block_size = block->m_size;
//All used blocks' next is marked with 0 so check it
BOOST_ASSERT(block->m_next == 0);
@@ -767,7 +774,7 @@
if(max_size < preferred_size)
return false;
- std::size_t data_size = block_size - BlockCtrlSize;
+ size_type data_size = block_size - BlockCtrlSize;
if(data_size < preferred_size)
return false;
@@ -801,21 +808,21 @@
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- priv_allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ priv_allocate_aligned(size_type nbytes, size_type alignment)
{
//Ensure power of 2
- if ((alignment & (alignment - std::size_t(1u))) != 0){
+ if ((alignment & (alignment - size_type(1u))) != 0){
//Alignment is not power of two
- BOOST_ASSERT((alignment & (alignment - std::size_t(1u))) != 0);
+ BOOST_ASSERT((alignment & (alignment - size_type(1u))) != 0);
return 0;
}
- std::size_t ignore;
+ size_type ignore;
if(alignment <= Alignment){
return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
}
- std::size_t request =
+ size_type request =
nbytes + alignment + MinBlockSize*Alignment - BlockCtrlBytes;
void *buffer = priv_allocate(boost::interprocess::allocate_new, request, request, ignore).first;
if(!buffer)
@@ -824,7 +831,7 @@
return buffer;
char *aligned_portion = reinterpret_cast<char*>
- (reinterpret_cast<std::size_t>(static_cast<char*>(buffer) + alignment - 1) & -alignment);
+ (reinterpret_cast<size_type>(static_cast<char*>(buffer) + alignment - 1) & -alignment);
char *pos = ((aligned_portion - reinterpret_cast<char*>(buffer)) >= (MinBlockSize*Alignment)) ?
aligned_portion : (aligned_portion + alignment);
@@ -834,7 +841,7 @@
block_ctrl *second = reinterpret_cast<block_ctrl*>(pos - BlockCtrlBytes);
- std::size_t old_size = first->m_size;
+ size_type old_size = first->m_size;
first->m_size = (reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
second->m_size = old_size - first->m_size;
@@ -849,19 +856,19 @@
template<class MutexFamily, class VoidPointer> inline
void* simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_check_and_allocate
- (std::size_t nunits
+ (size_type nunits
,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* prev
,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* block
- ,std::size_t &received_size)
+ ,size_type &received_size)
{
- std::size_t upper_nunits = nunits + BlockCtrlSize;
+ size_type upper_nunits = nunits + BlockCtrlSize;
bool found = false;
if (block->m_size > upper_nunits){
//This block is bigger than needed, split it in
//two blocks, the first's size will be (block->m_size-units)
//the second's size (units)
- std::size_t total_size = block->m_size;
+ size_type total_size = block->m_size;
block->m_size = nunits;
block_ctrl *new_block = reinterpret_cast<block_ctrl*>
(reinterpret_cast<char*>(block) + Alignment*nunits);
@@ -923,7 +930,7 @@
BOOST_ASSERT((reinterpret_cast<char*>(addr) - reinterpret_cast<char*>(this))
% Alignment == 0 );
- std::size_t total_size = Alignment*block->m_size;
+ size_type total_size = Alignment*block->m_size;
BOOST_ASSERT(m_header.m_allocated >= total_size);
//Update used memory count
Modified: trunk/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp (original)
+++ trunk/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -31,6 +31,8 @@
#include <boost/interprocess/detail/type_traits.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
#include <algorithm>
#include <utility>
#include <cstring>
@@ -57,6 +59,8 @@
simple_seq_fit_impl();
simple_seq_fit_impl(const simple_seq_fit_impl &);
simple_seq_fit_impl &operator=(const simple_seq_fit_impl &);
+
+ typedef typename boost::pointer_to_other<VoidPointer, char>::type char_ptr;
public:
@@ -67,6 +71,10 @@
typedef boost::container::containers_detail::
basic_multiallocation_chain<VoidPointer> multiallocation_chain;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+
+
private:
class block_ctrl;
typedef typename boost::
@@ -83,12 +91,12 @@
block_ctrl_ptr m_next;
//!This block's memory size (including block_ctrl
//!header) in BasicSize units
- std::size_t m_size;
+ size_type m_size;
- std::size_t get_user_bytes() const
+ size_type get_user_bytes() const
{ return this->m_size*Alignment - BlockCtrlBytes; }
- std::size_t get_total_bytes() const
+ size_type get_total_bytes() const
{ return this->m_size*Alignment; }
};
@@ -102,11 +110,11 @@
//!Pointer to the first free block
block_ctrl m_root;
//!Allocated bytes for internal checking
- std::size_t m_allocated;
+ size_type m_allocated;
//!The size of the memory segment
- std::size_t m_size;
+ size_type m_size;
//!The extra size required by the segment
- std::size_t m_extra_hdr_bytes;
+ size_type m_extra_hdr_bytes;
} m_header;
friend class detail::memory_algorithm_common<simple_seq_fit_impl>;
@@ -117,24 +125,24 @@
//!Constructor. "size" is the total size of the managed memory segment,
//!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit_impl)
//!offset that the allocator should not use at all.
- simple_seq_fit_impl (std::size_t size, std::size_t extra_hdr_bytes);
+ simple_seq_fit_impl (size_type size, size_type extra_hdr_bytes);
//!Destructor
~simple_seq_fit_impl();
//!Obtains the minimum size needed by the algorithm
- static std::size_t get_min_size (std::size_t extra_hdr_bytes);
+ static size_type get_min_size (size_type extra_hdr_bytes);
//Functions for single segment management
//!Allocates bytes, returns 0 if there is not more memory
- void* allocate (std::size_t nbytes);
+ void* allocate (size_type nbytes);
/// @cond
//!Multiple element allocation, same size
multiallocation_chain
- allocate_many(std::size_t elem_bytes, std::size_t num_elements)
+ allocate_many(size_type elem_bytes, size_type num_elements)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -144,7 +152,7 @@
//!Multiple element allocation, different size
multiallocation_chain
- allocate_many(const std::size_t *elem_sizes, std::size_t n_elements, std::size_t sizeof_element)
+ allocate_many(const size_type *elem_sizes, size_type n_elements, size_type sizeof_element)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -161,13 +169,13 @@
void deallocate (void *addr);
//!Returns the size of the memory segment
- std::size_t get_size() const;
+ size_type get_size() const;
//!Returns the number of free bytes of the memory segment
- std::size_t get_free_memory() const;
+ size_type get_free_memory() const;
//!Increases managed memory in extra_size bytes more
- void grow(std::size_t extra_size);
+ void grow(size_type extra_size);
//!Decreases managed memory as much as possible
void shrink_to_fit();
@@ -184,21 +192,21 @@
template<class T>
std::pair<T *, bool>
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr = 0);
std::pair<void *, bool>
- raw_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
- void *reuse_ptr = 0, std::size_t sizeof_object = 1);
+ raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
+ void *reuse_ptr = 0, size_type sizeof_object = 1);
//!Returns the size of the buffer previously allocated pointed by ptr
- std::size_t size(const void *ptr) const;
+ size_type size(const void *ptr) const;
//!Allocates aligned bytes, returns 0 if there is not more memory.
//!Alignment must be power of 2
- void* allocate_aligned (std::size_t nbytes, std::size_t alignment);
+ void* allocate_aligned (size_type nbytes, size_type alignment);
private:
@@ -210,24 +218,24 @@
//!Real allocation algorithm with min allocation option
std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr = 0);
std::pair<void *, bool> priv_allocation_command(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
- ,std::size_t sizeof_object);
+ ,size_type sizeof_object);
//!Returns the number of total units that a user buffer
//!of "userbytes" bytes really occupies (including header)
- static std::size_t priv_get_total_units(std::size_t userbytes);
+ static size_type priv_get_total_units(size_type userbytes);
- static std::size_t priv_first_block_offset(const void *this_ptr, std::size_t extra_hdr_bytes);
- std::size_t priv_block_end_offset() const;
+ static size_type priv_first_block_offset(const void *this_ptr, size_type extra_hdr_bytes);
+ size_type priv_block_end_offset() const;
//!Returns next block if it's free.
//!Returns 0 if next block is not free.
@@ -242,58 +250,59 @@
//!Real expand function implementation
bool priv_expand(void *ptr
- ,std::size_t min_size, std::size_t preferred_size
- ,std::size_t &received_size);
+ ,size_type min_size, size_type preferred_size
+ ,size_type &received_size);
//!Real expand to both sides implementation
void* priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards);
//!Real private aligned allocation function
- //void* priv_allocate_aligned (std::size_t nbytes, std::size_t alignment);
+ //void* priv_allocate_aligned (size_type nbytes, size_type alignment);
//!Checks if block has enough memory and splits/unlinks the block
//!returning the address to the users
- void* priv_check_and_allocate(std::size_t units
+ void* priv_check_and_allocate(size_type units
,block_ctrl* prev
,block_ctrl* block
- ,std::size_t &received_size);
+ ,size_type &received_size);
//!Real deallocation algorithm
void priv_deallocate(void *addr);
//!Makes a new memory portion available for allocation
- void priv_add_segment(void *addr, std::size_t size);
+ void priv_add_segment(void *addr, size_type size);
void priv_mark_new_allocated_block(block_ctrl *block);
public:
- static const std::size_t Alignment = detail::alignment_of<detail::max_align>::value;
+ static const size_type Alignment = ::boost::alignment_of< ::boost::detail::max_align>::value;
private:
- static const std::size_t BlockCtrlBytes = detail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
- static const std::size_t BlockCtrlUnits = BlockCtrlBytes/Alignment;
- static const std::size_t MinBlockUnits = BlockCtrlUnits;
- static const std::size_t MinBlockSize = MinBlockUnits*Alignment;
- static const std::size_t AllocatedCtrlBytes = BlockCtrlBytes;
- static const std::size_t AllocatedCtrlUnits = BlockCtrlUnits;
- static const std::size_t UsableByPreviousChunk = 0;
+ static const size_type BlockCtrlBytes = detail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
+ static const size_type BlockCtrlUnits = BlockCtrlBytes/Alignment;
+ static const size_type MinBlockUnits = BlockCtrlUnits;
+ static const size_type MinBlockSize = MinBlockUnits*Alignment;
+ static const size_type AllocatedCtrlBytes = BlockCtrlBytes;
+ static const size_type AllocatedCtrlUnits = BlockCtrlUnits;
+ static const size_type UsableByPreviousChunk = 0;
public:
- static const std::size_t PayloadPerAllocation = BlockCtrlBytes;
+ static const size_type PayloadPerAllocation = BlockCtrlBytes;
};
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>
- ::priv_first_block_offset(const void *this_ptr, std::size_t extra_hdr_bytes)
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>
+ ::priv_first_block_offset(const void *this_ptr, size_type extra_hdr_bytes)
{
//First align "this" pointer
- std::size_t uint_this = (std::size_t)this_ptr;
- std::size_t uint_aligned_this = uint_this/Alignment*Alignment;
- std::size_t this_disalignment = (uint_this - uint_aligned_this);
- std::size_t block1_off =
+ size_type uint_this = (std::size_t)this_ptr;
+ size_type uint_aligned_this = uint_this/Alignment*Alignment;
+ size_type this_disalignment = (uint_this - uint_aligned_this);
+ size_type block1_off =
detail::get_rounded_size(sizeof(simple_seq_fit_impl) + extra_hdr_bytes + this_disalignment, Alignment)
- this_disalignment;
algo_impl_t::assert_alignment(this_disalignment + block1_off);
@@ -301,14 +310,15 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>
::priv_block_end_offset() const
{
//First align "this" pointer
- std::size_t uint_this = (std::size_t)this;
- std::size_t uint_aligned_this = uint_this/Alignment*Alignment;
- std::size_t this_disalignment = (uint_this - uint_aligned_this);
- std::size_t old_end =
+ size_type uint_this = (std::size_t)this;
+ size_type uint_aligned_this = uint_this/Alignment*Alignment;
+ size_type this_disalignment = (uint_this - uint_aligned_this);
+ size_type old_end =
detail::get_truncated_size(m_header.m_size + this_disalignment, Alignment)
- this_disalignment;
algo_impl_t::assert_alignment(old_end + this_disalignment);
@@ -317,7 +327,7 @@
template<class MutexFamily, class VoidPointer>
inline simple_seq_fit_impl<MutexFamily, VoidPointer>::
- simple_seq_fit_impl(std::size_t size, std::size_t extra_hdr_bytes)
+ simple_seq_fit_impl(size_type size, size_type extra_hdr_bytes)
{
//Initialize sizes and counters
m_header.m_allocated = 0;
@@ -325,7 +335,7 @@
m_header.m_extra_hdr_bytes = extra_hdr_bytes;
//Initialize pointers
- std::size_t block1_off = priv_first_block_offset(this, extra_hdr_bytes);
+ size_type block1_off = priv_first_block_offset(this, extra_hdr_bytes);
m_header.m_root.m_next = reinterpret_cast<block_ctrl*>
((reinterpret_cast<char*>(this) + block1_off));
@@ -343,10 +353,10 @@
}
template<class MutexFamily, class VoidPointer>
-inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(std::size_t extra_size)
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(size_type extra_size)
{
//Old highest address block's end offset
- std::size_t old_end = this->priv_block_end_offset();
+ size_type old_end = this->priv_block_end_offset();
//Update managed buffer's size
m_header.m_size += extra_size;
@@ -398,16 +408,16 @@
void *unique_block = 0;
if(!m_header.m_allocated){
BOOST_ASSERT(prev == root);
- std::size_t ignore;
+ size_type ignore;
unique_block = priv_allocate(boost::interprocess::allocate_new, 0, 0, ignore).first;
if(!unique_block)
return;
last = detail::get_pointer(m_header.m_root.m_next);
BOOST_ASSERT(last_free_end_address == (reinterpret_cast<char*>(last) + last->m_size*Alignment));
}
- std::size_t last_units = last->m_size;
+ size_type last_units = last->m_size;
- std::size_t received_size;
+ size_type received_size;
void *addr = priv_check_and_allocate(last_units, prev, last, received_size);
(void)addr;
BOOST_ASSERT(addr);
@@ -448,7 +458,7 @@
}
template<class MutexFamily, class VoidPointer>
-inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, std::size_t size)
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, size_type size)
{
algo_impl_t::assert_alignment(addr);
//Check size
@@ -466,21 +476,24 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size() const
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size() const
{ return m_header.m_size; }
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::get_free_memory() const
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_free_memory() const
{
return m_header.m_size - m_header.m_allocated -
algo_impl_t::multiple_of_units(sizeof(*this) + m_header.m_extra_hdr_bytes);
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::
- get_min_size (std::size_t extra_hdr_bytes)
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+ get_min_size (size_type extra_hdr_bytes)
{
- return detail::get_rounded_size(sizeof(simple_seq_fit_impl),Alignment) +
+ return detail::get_rounded_size((size_type)sizeof(simple_seq_fit_impl),Alignment) +
detail::get_rounded_size(extra_hdr_bytes,Alignment)
+ MinBlockSize;
}
@@ -509,7 +522,7 @@
//Just clear user the memory part reserved for the user
std::memset( priv_get_user_buffer(block)
, 0
- , block->get_user_bytes());
+ , block->get_user_bytes());
block = detail::get_pointer(block->m_next);
}
while(block != &m_header.m_root);
@@ -524,7 +537,7 @@
//-----------------------
block_ctrl *block = detail::get_pointer(m_header.m_root.m_next);
- std::size_t free_memory = 0;
+ size_type free_memory = 0;
//Iterate through all blocks obtaining their size
while(block != &m_header.m_root){
@@ -554,18 +567,18 @@
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocate(std::size_t nbytes)
+ allocate(size_type nbytes)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
//-----------------------
- std::size_t ignore;
+ size_type ignore;
return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
}
template<class MutexFamily, class VoidPointer>
inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ allocate_aligned(size_type nbytes, size_type alignment)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -577,22 +590,22 @@
template<class MutexFamily, class VoidPointer>
template<class T>
inline std::pair<T*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr)
{
std::pair<void*, bool> ret = priv_allocation_command
(command, limit_size, preferred_size, received_size, static_cast<void*>(reuse_ptr), sizeof(T));
- BOOST_ASSERT(0 == ((std::size_t)ret.first % detail::alignment_of<T>::value));
+ BOOST_ASSERT(0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value));
return std::pair<T *, bool>(static_cast<T*>(ret.first), ret.second);
}
template<class MutexFamily, class VoidPointer>
inline std::pair<void*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
- raw_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_objects,
- std::size_t preferred_objects,std::size_t &received_objects,
- void *reuse_ptr, std::size_t sizeof_object)
+ raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects,
+ size_type preferred_objects,size_type &received_objects,
+ void *reuse_ptr, size_type sizeof_object)
{
if(!sizeof_object)
return std::pair<void *, bool>(static_cast<void*>(0), false);
@@ -609,21 +622,21 @@
template<class MutexFamily, class VoidPointer>
inline std::pair<void*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
- priv_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size, std::size_t &received_size,
- void *reuse_ptr, std::size_t sizeof_object)
+ priv_allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size, size_type &received_size,
+ void *reuse_ptr, size_type sizeof_object)
{
command &= ~boost::interprocess::expand_bwd;
if(!command) return std::pair<void *, bool>(static_cast<void*>(0), false);
std::pair<void*, bool> ret;
- std::size_t max_count = m_header.m_size/sizeof_object;
+ size_type max_count = m_header.m_size/sizeof_object;
if(limit_size > max_count || preferred_size > max_count){
ret.first = 0; return ret;
}
- std::size_t l_size = limit_size*sizeof_object;
- std::size_t p_size = preferred_size*sizeof_object;
- std::size_t r_size;
+ size_type l_size = limit_size*sizeof_object;
+ size_type p_size = preferred_size*sizeof_object;
+ size_type r_size;
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -635,7 +648,8 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
size(const void *ptr) const
{
//We need no synchronization since this block is not going
@@ -648,9 +662,9 @@
template<class MutexFamily, class VoidPointer>
void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards)
{
@@ -671,14 +685,14 @@
received_size = this->size(reuse_ptr);
}
if(command & boost::interprocess::expand_bwd){
- std::size_t extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
+ size_type extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
prev_block_t prev_pair = priv_prev_block_if_free(reuse);
block_ctrl *prev = prev_pair.second;
if(!prev){
return 0;
}
- std::size_t needs_backwards =
+ size_type needs_backwards =
detail::get_rounded_size(preferred_size - extra_forward, Alignment);
if(!only_preferred_backwards){
@@ -739,10 +753,11 @@
}
template<class MutexFamily, class VoidPointer>
-inline std::size_t simple_seq_fit_impl<MutexFamily, VoidPointer>::
- priv_get_total_units(std::size_t userbytes)
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+ priv_get_total_units(size_type userbytes)
{
- std::size_t s = detail::get_rounded_size(userbytes, Alignment)/Alignment;
+ size_type s = detail::get_rounded_size(userbytes, Alignment)/Alignment;
if(!s) ++s;
return BlockCtrlUnits + s;
}
@@ -750,9 +765,9 @@
template<class MutexFamily, class VoidPointer>
std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t limit_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type limit_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr)
{
if(command & boost::interprocess::shrink_in_place){
@@ -767,7 +782,7 @@
return return_type(static_cast<void*>(0), false);
//Number of units to request (including block_ctrl header)
- std::size_t nunits = detail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlUnits;
+ size_type nunits = detail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlUnits;
//Get the root and the first memory block
block_ctrl *prev = &m_header.m_root;
@@ -775,7 +790,7 @@
block_ctrl *root = &m_header.m_root;
block_ctrl *biggest_block = 0;
block_ctrl *prev_biggest_block = 0;
- std::size_t biggest_size = 0;
+ size_type biggest_size = 0;
//Expand in place
//reuse_ptr, limit_size, preferred_size, received_size
@@ -812,7 +827,7 @@
//Bad luck finding preferred_size, now if we have any biggest_block
//try with this block
if(biggest_block){
- std::size_t limit_units = detail::get_rounded_size(limit_size, Alignment)/Alignment + BlockCtrlUnits;
+ size_type limit_units = detail::get_rounded_size(limit_size, Alignment)/Alignment + BlockCtrlUnits;
if(biggest_block->m_size < limit_units)
return return_type(static_cast<void*>(0), false);
@@ -852,7 +867,7 @@
//Check if the adjacent block is in the managed segment
char *this_char_ptr = reinterpret_cast<char*>(this);
char *next_char_ptr = reinterpret_cast<char*>(next_block);
- std::size_t distance = (next_char_ptr - this_char_ptr)/Alignment;
+ size_type distance = (size_type)(next_char_ptr - this_char_ptr)/Alignment;
if(distance >= (m_header.m_size/Alignment)){
//"next_block" does not exist so we can't expand "block"
@@ -892,7 +907,7 @@
//Check if the previous block is in the managed segment
char *this_char_ptr = reinterpret_cast<char*>(this);
char *prev_char_ptr = reinterpret_cast<char*>(prev_block);
- std::size_t distance = (prev_char_ptr - this_char_ptr)/Alignment;
+ size_type distance = (size_type)(prev_char_ptr - this_char_ptr)/Alignment;
if(distance >= (m_header.m_size/Alignment)){
//"previous_block" does not exist so we can't expand "block"
@@ -905,13 +920,13 @@
template<class MutexFamily, class VoidPointer>
inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
priv_expand (void *ptr
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size)
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size)
{
//Obtain the real size of the block
block_ctrl *block = reinterpret_cast<block_ctrl*>(priv_get_block(ptr));
- std::size_t old_block_size = block->m_size;
+ size_type old_block_size = block->m_size;
//All used blocks' next is marked with 0 so check it
BOOST_ASSERT(block->m_next == 0);
@@ -927,7 +942,7 @@
if(min_size > preferred_size)
return false;
- std::size_t data_size = old_block_size - BlockCtrlUnits;
+ size_type data_size = old_block_size - BlockCtrlUnits;
if(data_size >= min_size)
return true;
@@ -938,7 +953,7 @@
}
//Is "block" + "next_block" big enough?
- std::size_t merged_size = old_block_size + next_block->m_size;
+ size_type merged_size = old_block_size + next_block->m_size;
//Now we can expand this block further than before
received_size = merged_size*Alignment - BlockCtrlBytes;
@@ -964,7 +979,7 @@
//Now use check and allocate to do the allocation logic
preferred_size += BlockCtrlUnits;
- std::size_t nunits = preferred_size < merged_size ? preferred_size : merged_size;
+ size_type nunits = preferred_size < merged_size ? preferred_size : merged_size;
//This must success since nunits is less than merged_size!
if(!this->priv_check_and_allocate (nunits, prev, block, received_size)){
@@ -978,19 +993,19 @@
template<class MutexFamily, class VoidPointer> inline
void* simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_check_and_allocate
- (std::size_t nunits
+ (size_type nunits
,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* prev
,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* block
- ,std::size_t &received_size)
+ ,size_type &received_size)
{
- std::size_t upper_nunits = nunits + BlockCtrlUnits;
+ size_type upper_nunits = nunits + BlockCtrlUnits;
bool found = false;
if (block->m_size > upper_nunits){
//This block is bigger than needed, split it in
//two blocks, the first's size will be "units"
//the second's size will be "block->m_size-units"
- std::size_t total_size = block->m_size;
+ size_type total_size = block->m_size;
block->m_size = nunits;
block_ctrl *new_block = reinterpret_cast<block_ctrl*>
@@ -1050,7 +1065,7 @@
//Check if alignment and block size are right
algo_impl_t::assert_alignment(addr);
- std::size_t total_size = Alignment*block->m_size;
+ size_type total_size = Alignment*block->m_size;
BOOST_ASSERT(m_header.m_allocated >= total_size);
//Update used memory count
Modified: trunk/boost/interprocess/mem_algo/rbtree_best_fit.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/rbtree_best_fit.hpp (original)
+++ trunk/boost/interprocess/mem_algo/rbtree_best_fit.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -32,12 +32,13 @@
#include <boost/interprocess/detail/math_functions.hpp>
#include <boost/interprocess/detail/type_traits.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
#include <algorithm>
#include <utility>
#include <climits>
-#include <boost/assert.hpp>
#include <cstring>
#include <iterator>
@@ -46,6 +47,11 @@
#include <boost/intrusive/set.hpp>
+//#define BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+//to maintain ABI compatible with the original version
+//ABI had to be updated to fix compatibility issues when
+//sharing shared memory between 32 adn 64 bit processes.
+
//!\file
//!Describes a best-fit algorithm based in an intrusive red-black tree used to allocate
//!objects in shared memory. This class is intended as a base class for single segment
@@ -64,6 +70,14 @@
rbtree_best_fit();
rbtree_best_fit(const rbtree_best_fit &);
rbtree_best_fit &operator=(const rbtree_best_fit &);
+
+ private:
+ struct block_ctrl;
+ typedef typename boost::
+ pointer_to_other<VoidPointer, block_ctrl>::type block_ctrl_ptr;
+ typedef typename boost::
+ pointer_to_other<VoidPointer, char>::type char_ptr;
+
/// @endcond
public:
@@ -74,14 +88,12 @@
typedef boost::container::containers_detail::
basic_multiallocation_chain<VoidPointer> multiallocation_chain;
+ typedef typename std::iterator_traits<char_ptr>::difference_type difference_type;
+ typedef typename boost::make_unsigned<difference_type>::type size_type;
+
/// @cond
private:
- struct block_ctrl;
- typedef typename boost::
- pointer_to_other<void_pointer, block_ctrl>::type block_ctrl_ptr;
- typedef typename boost::
- pointer_to_other<void_pointer, char>::type char_ptr;
typedef typename bi::make_set_base_hook
< bi::void_pointer<VoidPointer>
@@ -92,10 +104,10 @@
{
//!This block's memory size (including block_ctrl
//!header) in Alignment units
- std::size_t m_prev_size : sizeof(std::size_t)*CHAR_BIT;
- std::size_t m_size : sizeof(std::size_t)*CHAR_BIT - 2;
- std::size_t m_prev_allocated : 1;
- std::size_t m_allocated : 1;
+ size_type m_prev_size : sizeof(size_type)*CHAR_BIT;
+ size_type m_size : sizeof(size_type)*CHAR_BIT - 2;
+ size_type m_prev_allocated : 1;
+ size_type m_allocated : 1;
};
//!Block control structure
@@ -113,10 +125,10 @@
struct size_block_ctrl_compare
{
- bool operator()(std::size_t size, const block_ctrl &block) const
+ bool operator()(size_type size, const block_ctrl &block) const
{ return size < block.m_size; }
- bool operator()(const block_ctrl &block, std::size_t size) const
+ bool operator()(const block_ctrl &block, size_type size) const
{ return block.m_size < size; }
};
@@ -134,11 +146,11 @@
Imultiset m_imultiset;
//!The extra size required by the segment
- std::size_t m_extra_hdr_bytes;
+ size_type m_extra_hdr_bytes;
//!Allocated bytes for internal checking
- std::size_t m_allocated;
+ size_type m_allocated;
//!The size of the memory segment
- std::size_t m_size;
+ size_type m_size;
} m_header;
friend class detail::memory_algorithm_common<rbtree_best_fit>;
@@ -151,25 +163,25 @@
//!Constructor. "size" is the total size of the managed memory segment,
//!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(rbtree_best_fit)
//!offset that the allocator should not use at all.
- rbtree_best_fit (std::size_t size, std::size_t extra_hdr_bytes);
+ rbtree_best_fit (size_type size, size_type extra_hdr_bytes);
//!Destructor.
~rbtree_best_fit();
//!Obtains the minimum size needed by the algorithm
- static std::size_t get_min_size (std::size_t extra_hdr_bytes);
+ static size_type get_min_size (size_type extra_hdr_bytes);
//Functions for single segment management
//!Allocates bytes, returns 0 if there is not more memory
- void* allocate (std::size_t nbytes);
+ void* allocate (size_type nbytes);
/// @cond
//Experimental. Dont' use
//!Multiple element allocation, same size
- multiallocation_chain allocate_many(std::size_t elem_bytes, std::size_t num_elements)
+ multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
{
//-----------------------
@@ -179,7 +191,7 @@
}
//!Multiple element allocation, different size
- multiallocation_chain allocate_many(const std::size_t *elem_sizes, std::size_t n_elements, std::size_t sizeof_element)
+ multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, size_type sizeof_element)
{
//-----------------------
@@ -197,10 +209,10 @@
void deallocate (void *addr);
//!Returns the size of the memory segment
- std::size_t get_size() const;
+ size_type get_size() const;
//!Returns the number of free bytes of the segment
- std::size_t get_free_memory() const;
+ size_type get_free_memory() const;
//!Initializes to zero all the memory that's not in use.
//!This function is normally used for security reasons.
@@ -208,7 +220,7 @@
//!Increases managed memory in
//!extra_size bytes more
- void grow(std::size_t extra_size);
+ void grow(size_type extra_size);
//!Decreases managed memory as much as possible
void shrink_to_fit();
@@ -222,39 +234,43 @@
template<class T>
std::pair<T *, bool>
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr = 0);
std::pair<void *, bool>
- raw_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_object,
- std::size_t preferred_object,std::size_t &received_object,
- void *reuse_ptr = 0, std::size_t sizeof_object = 1);
+ raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_object,
+ size_type preferred_object,size_type &received_object,
+ void *reuse_ptr = 0, size_type sizeof_object = 1);
//!Returns the size of the buffer previously allocated pointed by ptr
- std::size_t size(const void *ptr) const;
+ size_type size(const void *ptr) const;
//!Allocates aligned bytes, returns 0 if there is not more memory.
//!Alignment must be power of 2
- void* allocate_aligned (std::size_t nbytes, std::size_t alignment);
+ void* allocate_aligned (size_type nbytes, size_type alignment);
/// @cond
private:
- static std::size_t priv_first_block_offset(const void *this_ptr, std::size_t extra_hdr_bytes);
+ static size_type priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes);
+
+ block_ctrl *priv_first_block();
+
+ block_ctrl *priv_end_block();
std::pair<void*, bool>
- priv_allocation_command(boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
- void *reuse_ptr, std::size_t sizeof_object);
+ priv_allocation_command(boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
+ void *reuse_ptr, size_type sizeof_object);
//!Real allocation algorithm with min allocation option
std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t limit_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type limit_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr = 0
- ,std::size_t backwards_multiple = 1);
+ ,size_type backwards_multiple = 1);
//!Obtains the block control structure of the user buffer
static block_ctrl *priv_get_block(const void *ptr);
@@ -264,33 +280,36 @@
//!Returns the number of total units that a user buffer
//!of "userbytes" bytes really occupies (including header)
- static std::size_t priv_get_total_units(std::size_t userbytes);
+ static size_type priv_get_total_units(size_type userbytes);
//!Real expand function implementation
bool priv_expand(void *ptr
- ,const std::size_t min_size, const std::size_t preferred_size
- ,std::size_t &received_size);
+ ,const size_type min_size, const size_type preferred_size
+ ,size_type &received_size);
//!Real expand to both sides implementation
void* priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards
- ,std::size_t backwards_multiple);
-
- //!Get poitner of the previous block (previous block must be free)
- block_ctrl * priv_prev_block(block_ctrl *ptr);
+ ,size_type backwards_multiple);
//!Returns true if the previous block is allocated
bool priv_is_prev_allocated(block_ctrl *ptr);
//!Get a pointer of the "end" block from the first block of the segment
- block_ctrl * priv_end_block(block_ctrl *first_segment_block);
+ static block_ctrl * priv_end_block(block_ctrl *first_segment_block);
+
+ //!Get a pointer of the "first" block from the end block of the segment
+ static block_ctrl * priv_first_block(block_ctrl *end_segment_block);
+
+ //!Get poitner of the previous block (previous block must be free)
+ static block_ctrl * priv_prev_block(block_ctrl *ptr);
//!Get the size in the tail of the previous block
- block_ctrl * priv_next_block(block_ctrl *ptr);
+ static block_ctrl * priv_next_block(block_ctrl *ptr);
//!Check if this block is free (not allocated)
bool priv_is_allocated_block(block_ctrl *ptr);
@@ -299,25 +318,27 @@
void priv_mark_as_allocated_block(block_ctrl *ptr);
//!Marks the block as allocated
+ void priv_mark_new_allocated_block(block_ctrl *ptr)
+ { return priv_mark_as_allocated_block(ptr); }
+
+ //!Marks the block as allocated
void priv_mark_as_free_block(block_ctrl *ptr);
//!Checks if block has enough memory and splits/unlinks the block
//!returning the address to the users
- void* priv_check_and_allocate(std::size_t units
+ void* priv_check_and_allocate(size_type units
,block_ctrl* block
- ,std::size_t &received_size);
+ ,size_type &received_size);
//!Real deallocation algorithm
void priv_deallocate(void *addr);
//!Makes a new memory portion available for allocation
- void priv_add_segment(void *addr, std::size_t size);
-
- void priv_mark_new_allocated_block(block_ctrl *block);
+ void priv_add_segment(void *addr, size_type size);
public:
- static const std::size_t Alignment = !MemAlignment
- ? detail::alignment_of<detail::max_align>::value
+ static const size_type Alignment = !MemAlignment
+ ? ::boost::alignment_of< ::boost::detail::max_align>::value
: MemAlignment
;
@@ -325,42 +346,109 @@
//Due to embedded bits in size, Alignment must be at least 4
BOOST_STATIC_ASSERT((Alignment >= 4));
//Due to rbtree size optimizations, Alignment must have at least pointer alignment
- BOOST_STATIC_ASSERT((Alignment >= detail::alignment_of<void_pointer>::value));
- static const std::size_t AlignmentMask = (Alignment - 1);
- static const std::size_t BlockCtrlBytes = detail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
- static const std::size_t BlockCtrlUnits = BlockCtrlBytes/Alignment;
- static const std::size_t AllocatedCtrlBytes = detail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
- static const std::size_t AllocatedCtrlUnits = AllocatedCtrlBytes/Alignment;
- static const std::size_t EndCtrlBlockBytes = detail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
- static const std::size_t EndCtrlBlockUnits = EndCtrlBlockBytes/Alignment;
- static const std::size_t MinBlockUnits = BlockCtrlUnits;
- static const std::size_t UsableByPreviousChunk = sizeof(std::size_t);
+ BOOST_STATIC_ASSERT((Alignment >= ::boost::alignment_of<void_pointer>::value));
+ static const size_type AlignmentMask = (Alignment - 1);
+ static const size_type BlockCtrlBytes = detail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
+ static const size_type BlockCtrlUnits = BlockCtrlBytes/Alignment;
+ static const size_type AllocatedCtrlBytes = detail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
+ static const size_type AllocatedCtrlUnits = AllocatedCtrlBytes/Alignment;
+ static const size_type EndCtrlBlockBytes = detail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
+ static const size_type EndCtrlBlockUnits = EndCtrlBlockBytes/Alignment;
+ static const size_type MinBlockUnits = BlockCtrlUnits;
+ static const size_type UsableByPreviousChunk = sizeof(size_type);
//Make sure the maximum alignment is power of two
- BOOST_STATIC_ASSERT((0 == (Alignment & (Alignment - std::size_t(1u)))));
+ BOOST_STATIC_ASSERT((0 == (Alignment & (Alignment - size_type(1u)))));
/// @endcond
public:
- static const std::size_t PayloadPerAllocation = AllocatedCtrlBytes - UsableByPreviousChunk;
+ static const size_type PayloadPerAllocation = AllocatedCtrlBytes - UsableByPreviousChunk;
};
/// @cond
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
- ::priv_first_block_offset(const void *this_ptr, std::size_t extra_hdr_bytes)
-{
- std::size_t uint_this = (std::size_t)this_ptr;
- std::size_t main_hdr_end = uint_this + sizeof(rbtree_best_fit) + extra_hdr_bytes;
- std::size_t aligned_main_hdr_end = detail::get_rounded_size(main_hdr_end, Alignment);
- std::size_t block1_off = aligned_main_hdr_end - uint_this;
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+ rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+ ::priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes)
+{
+ size_type uint_this = (std::size_t)this_ptr;
+ size_type main_hdr_end = uint_this + sizeof(rbtree_best_fit) + extra_hdr_bytes;
+ size_type aligned_main_hdr_end = detail::get_rounded_size(main_hdr_end, Alignment);
+ size_type block1_off = aligned_main_hdr_end - uint_this;
algo_impl_t::assert_alignment(aligned_main_hdr_end);
algo_impl_t::assert_alignment(uint_this + block1_off);
return block1_off;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+ priv_add_segment(void *addr, size_type size)
+{
+ //Check alignment
+ algo_impl_t::check_alignment(addr);
+ //Check size
+ BOOST_ASSERT(size >= (BlockCtrlBytes + EndCtrlBlockBytes));
+
+ //Initialize the first big block and the "end" node
+ block_ctrl *first_big_block = new(addr)block_ctrl;
+ first_big_block->m_size = size/Alignment - EndCtrlBlockUnits;
+ BOOST_ASSERT(first_big_block->m_size >= BlockCtrlUnits);
+
+ //The "end" node is just a node of size 0 with the "end" bit set
+ block_ctrl *end_block = static_cast<block_ctrl*>
+ (new (reinterpret_cast<char*>(addr) + first_big_block->m_size*Alignment)SizeHolder);
+
+ //This will overwrite the prev part of the "end" node
+ priv_mark_as_free_block (first_big_block);
+ #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+ first_big_block->m_prev_size = end_block->m_size =
+ (reinterpret_cast<char*>(first_big_block) - reinterpret_cast<char*>(end_block))/Alignment;
+ #else
+ first_big_block->m_prev_size = end_block->m_size =
+ (reinterpret_cast<char*>(end_block) - reinterpret_cast<char*>(first_big_block))/Alignment;
+ #endif
+ end_block->m_allocated = 1;
+ first_big_block->m_prev_allocated = 1;
+
+ BOOST_ASSERT(priv_next_block(first_big_block) == end_block);
+ BOOST_ASSERT(priv_prev_block(end_block) == first_big_block);
+ BOOST_ASSERT(priv_first_block() == first_big_block);
+ BOOST_ASSERT(priv_end_block() == end_block);
+
+ //Some check to validate the algorithm, since it makes some assumptions
+ //to optimize the space wasted in bookkeeping:
+
+ //Check that the sizes of the header are placed before the rbtree
+ BOOST_ASSERT(static_cast<void*>(static_cast<SizeHolder*>(first_big_block))
+ < static_cast<void*>(static_cast<TreeHook*>(first_big_block)));
+ //Insert it in the intrusive containers
+ m_header.m_imultiset.insert(*first_big_block);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+ rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+ ::priv_first_block()
+{
+ size_type block1_off = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+ return reinterpret_cast<block_ctrl *>(reinterpret_cast<char*>(this) + block1_off);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+ rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+ ::priv_end_block()
+{
+ size_type block1_off = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+ const size_type original_first_block_size = m_header.m_size/Alignment*Alignment - block1_off/Alignment*Alignment - EndCtrlBlockBytes;
+ block_ctrl *end_block = reinterpret_cast<block_ctrl*>
+ (reinterpret_cast<char*>(this) + block1_off + original_first_block_size);
+ return end_block;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- rbtree_best_fit(std::size_t size, std::size_t extra_hdr_bytes)
+ rbtree_best_fit(size_type size, size_type extra_hdr_bytes)
{
//Initialize the header
m_header.m_allocated = 0;
@@ -370,7 +458,7 @@
//Now write calculate the offset of the first big block that will
//cover the whole segment
BOOST_ASSERT(get_min_size(extra_hdr_bytes) <= size);
- std::size_t block1_off = priv_first_block_offset(this, extra_hdr_bytes);
+ size_type block1_off = priv_first_block_offset_from_this(this, extra_hdr_bytes);
priv_add_segment(reinterpret_cast<char*>(this) + block1_off, size - block1_off);
}
@@ -383,49 +471,51 @@
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::grow(std::size_t extra_size)
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::grow(size_type extra_size)
{
//Get the address of the first block
- std::size_t block1_off =
- priv_first_block_offset(this, m_header.m_extra_hdr_bytes);
-
- block_ctrl *first_block = reinterpret_cast<block_ctrl *>
- (reinterpret_cast<char*>(this) + block1_off);
- block_ctrl *old_end_block = priv_end_block(first_block);
- BOOST_ASSERT(priv_is_allocated_block(old_end_block));
- std::size_t old_border_offset = (reinterpret_cast<char*>(old_end_block) -
+ block_ctrl *first_block = priv_first_block();
+ block_ctrl *old_end_block = priv_end_block();
+ size_type old_border_offset = (size_type)(reinterpret_cast<char*>(old_end_block) -
reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;
//Update managed buffer's size
m_header.m_size += extra_size;
//We need at least MinBlockUnits blocks to create a new block
-// BOOST_ASSERT((m_header.m_size - old_end) >= MinBlockUnits);
if((m_header.m_size - old_border_offset) < MinBlockUnits){
return;
}
//Now create a new block between the old end and the new end
- std::size_t align_offset = (m_header.m_size - old_border_offset)/Alignment;
+ size_type align_offset = (m_header.m_size - old_border_offset)/Alignment;
block_ctrl *new_end_block = reinterpret_cast<block_ctrl*>
(reinterpret_cast<char*>(old_end_block) + align_offset*Alignment);
+
+ //the last and first block are special:
+ //new_end_block->m_size & first_block->m_prev_size store the absolute value
+ //between them
+ new_end_block->m_allocated = 1;
+ #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
new_end_block->m_size = (reinterpret_cast<char*>(first_block) -
reinterpret_cast<char*>(new_end_block))/Alignment;
+ #else
+ new_end_block->m_size = (reinterpret_cast<char*>(new_end_block) -
+ reinterpret_cast<char*>(first_block))/Alignment;
+ #endif
first_block->m_prev_size = new_end_block->m_size;
- BOOST_ASSERT(first_block == priv_next_block(new_end_block));
- priv_mark_new_allocated_block(new_end_block);
-
- BOOST_ASSERT(new_end_block == priv_end_block(first_block));
+ first_block->m_prev_allocated = 1;
+ BOOST_ASSERT(new_end_block == priv_end_block());
//The old end block is the new block
block_ctrl *new_block = old_end_block;
new_block->m_size = (reinterpret_cast<char*>(new_end_block) -
reinterpret_cast<char*>(new_block))/Alignment;
BOOST_ASSERT(new_block->m_size >= BlockCtrlUnits);
- priv_mark_new_allocated_block(new_block);
+ priv_mark_as_allocated_block(new_block);
BOOST_ASSERT(priv_next_block(new_block) == new_end_block);
- m_header.m_allocated += new_block->m_size*Alignment;
+ m_header.m_allocated += (size_type)new_block->m_size*Alignment;
//Now deallocate the newly created block
this->priv_deallocate(priv_get_user_buffer(new_block));
@@ -433,30 +523,27 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::shrink_to_fit()
-{
+{
//Get the address of the first block
- std::size_t block1_off =
- priv_first_block_offset(this, m_header.m_extra_hdr_bytes);
-
- block_ctrl *first_block = reinterpret_cast<block_ctrl*>
- (reinterpret_cast<char*>(this) + block1_off);
+ block_ctrl *first_block = priv_first_block();
algo_impl_t::assert_alignment(first_block);
- block_ctrl *old_end_block = priv_end_block(first_block);
- algo_impl_t::assert_alignment(old_end_block);
- BOOST_ASSERT(priv_is_allocated_block(old_end_block));
-
+ //block_ctrl *old_end_block = priv_end_block(first_block);
+ block_ctrl *old_end_block = priv_end_block();
algo_impl_t::assert_alignment(old_end_block);
-
- std::size_t old_end_block_size = old_end_block->m_size;
+ size_type old_end_block_size = old_end_block->m_size;
void *unique_buffer = 0;
block_ctrl *last_block;
+ //Check if no memory is allocated between the first and last block
if(priv_next_block(first_block) == old_end_block){
- std::size_t ignore;
+ //If so check if we can allocate memory
+ size_type ignore;
unique_buffer = priv_allocate(boost::interprocess::allocate_new, 0, 0, ignore).first;
+ //If not, return, we can't shrink
if(!unique_buffer)
return;
+ //If we can, mark the position just after the new allocation as the new end
algo_impl_t::assert_alignment(unique_buffer);
block_ctrl *unique_block = priv_get_block(unique_buffer);
BOOST_ASSERT(priv_is_allocated_block(unique_block));
@@ -466,97 +553,62 @@
algo_impl_t::assert_alignment(last_block);
}
else{
+ //If memory is allocated, check if the last block is allocated
if(priv_is_prev_allocated(old_end_block))
return;
+ //If not, mark last block after the free block
last_block = priv_prev_block(old_end_block);
}
- std::size_t last_block_size = last_block->m_size;
+ size_type last_block_size = last_block->m_size;
//Erase block from the free tree, since we will erase it
m_header.m_imultiset.erase(Imultiset::s_iterator_to(*last_block));
- std::size_t shrunk_border_offset = (reinterpret_cast<char*>(last_block) -
+ size_type shrunk_border_offset = (size_type)(reinterpret_cast<char*>(last_block) -
reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;
block_ctrl *new_end_block = last_block;
algo_impl_t::assert_alignment(new_end_block);
- new_end_block->m_size = old_end_block_size + last_block_size;
- priv_mark_as_allocated_block(new_end_block);
- //Although the first block might be allocated, we'll
- //store the offset to the end block since in the previous
- //offset can't be overwritten by a previous block
- first_block->m_prev_size = new_end_block->m_size;
- BOOST_ASSERT(priv_end_block(first_block) == new_end_block);
+ //Write new end block attributes
+ #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+ new_end_block->m_size = first_block->m_prev_size =
+ (reinterpret_cast<char*>(first_block) - reinterpret_cast<char*>(new_end_block))/Alignment;
+ #else
+ new_end_block->m_size = first_block->m_prev_size =
+ (reinterpret_cast<char*>(new_end_block) - reinterpret_cast<char*>(first_block))/Alignment;
+ #endif
+
+ new_end_block->m_allocated = 1;
+ (void)last_block_size;
+ (void)old_end_block_size;
+ BOOST_ASSERT(new_end_block->m_size == (old_end_block_size - last_block_size));
//Update managed buffer's size
m_header.m_size = shrunk_border_offset;
+ BOOST_ASSERT(priv_end_block() == new_end_block);
if(unique_buffer)
priv_deallocate(unique_buffer);
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- priv_add_segment(void *addr, std::size_t size)
-{
- //Check alignment
- algo_impl_t::check_alignment(addr);
- //Check size
- BOOST_ASSERT(size >= (BlockCtrlBytes + EndCtrlBlockBytes));
-
- //Initialize the first big block and the "end" node
- block_ctrl *first_big_block = new(addr)block_ctrl;
- first_big_block->m_size = size/Alignment - EndCtrlBlockUnits;
- BOOST_ASSERT(first_big_block->m_size >= BlockCtrlUnits);
-
- //The "end" node is just a node of size 0 with the "end" bit set
- block_ctrl *end_block = static_cast<block_ctrl*>
- (new (reinterpret_cast<char*>(addr) + first_big_block->m_size*Alignment)SizeHolder);
-
- //This will overwrite the prev part of the "end" node
- priv_mark_as_free_block (first_big_block);
- first_big_block->m_prev_size = end_block->m_size =
- (reinterpret_cast<char*>(first_big_block) - reinterpret_cast<char*>(end_block))/Alignment;
- priv_mark_as_allocated_block(end_block);
-
- BOOST_ASSERT(priv_next_block(first_big_block) == end_block);
- BOOST_ASSERT(priv_next_block(end_block) == first_big_block);
- BOOST_ASSERT(priv_end_block(first_big_block) == end_block);
- BOOST_ASSERT(priv_prev_block(end_block) == first_big_block);
-
- //Some check to validate the algorithm, since it makes some assumptions
- //to optimize the space wasted in bookkeeping:
-
- //Check that the sizes of the header are placed before the rbtree
- BOOST_ASSERT(static_cast<void*>(static_cast<SizeHolder*>(first_big_block))
- < static_cast<void*>(static_cast<TreeHook*>(first_big_block)));
-
- //Check that the alignment is power of two (we use some optimizations based on this)
- //BOOST_ASSERT((Alignment % 2) == 0);
- //Insert it in the intrusive containers
- m_header.m_imultiset.insert(*first_big_block);
-}
-
-template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- priv_mark_new_allocated_block(block_ctrl *new_block)
-{ priv_mark_as_allocated_block(new_block); }
-
-template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_size() const
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_size() const
{ return m_header.m_size; }
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_free_memory() const
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_free_memory() const
{
return m_header.m_size - m_header.m_allocated -
- priv_first_block_offset(this, m_header.m_extra_hdr_bytes);
+ priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- get_min_size (std::size_t extra_hdr_bytes)
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+ get_min_size (size_type extra_hdr_bytes)
{
return (algo_impl_t::ceil_units(sizeof(rbtree_best_fit)) +
algo_impl_t::ceil_units(extra_hdr_bytes) +
@@ -570,8 +622,8 @@
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
//-----------------------
- std::size_t block1_off =
- priv_first_block_offset(this, m_header.m_extra_hdr_bytes);
+ size_type block1_off =
+ priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
return m_header.m_allocated == 0 &&
m_header.m_imultiset.begin() != m_header.m_imultiset.end() &&
@@ -589,11 +641,11 @@
//-----------------------
imultiset_iterator ib(m_header.m_imultiset.begin()), ie(m_header.m_imultiset.end());
- std::size_t free_memory = 0;
+ size_type free_memory = 0;
//Iterate through all blocks obtaining their size
for(; ib != ie; ++ib){
- free_memory += ib->m_size*Alignment;
+ free_memory += (size_type)ib->m_size*Alignment;
algo_impl_t::assert_alignment(&*ib);
if(!algo_impl_t::check_alignment(&*ib))
return false;
@@ -604,8 +656,8 @@
return false;
}
- std::size_t block1_off =
- priv_first_block_offset(this, m_header.m_extra_hdr_bytes);
+ size_type block1_off =
+ priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
//Check free bytes are less than size
if(free_memory > (m_header.m_size - block1_off)){
@@ -616,19 +668,19 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- allocate(std::size_t nbytes)
+ allocate(size_type nbytes)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
//-----------------------
- std::size_t ignore;
+ size_type ignore;
void * ret = priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
return ret;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ allocate_aligned(size_type nbytes, size_type alignment)
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -639,22 +691,22 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
template<class T>
inline std::pair<T*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr)
{
std::pair<void*, bool> ret = priv_allocation_command
(command, limit_size, preferred_size, received_size, static_cast<void*>(reuse_ptr), sizeof(T));
- BOOST_ASSERT(0 == ((std::size_t)ret.first % detail::alignment_of<T>::value));
+ BOOST_ASSERT(0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value));
return std::pair<T *, bool>(static_cast<T*>(ret.first), ret.second);
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- raw_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_objects,
- std::size_t preferred_objects,std::size_t &received_objects,
- void *reuse_ptr, std::size_t sizeof_object)
+ raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects,
+ size_type preferred_objects,size_type &received_objects,
+ void *reuse_ptr, size_type sizeof_object)
{
if(!sizeof_object)
return std::pair<void *, bool>(static_cast<void*>(0), false);
@@ -672,18 +724,18 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- priv_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
- void *reuse_ptr, std::size_t sizeof_object)
+ priv_allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
+ void *reuse_ptr, size_type sizeof_object)
{
std::pair<void*, bool> ret;
- std::size_t max_count = m_header.m_size/sizeof_object;
+ size_type max_count = m_header.m_size/sizeof_object;
if(limit_size > max_count || preferred_size > max_count){
ret.first = 0; return ret;
}
- std::size_t l_size = limit_size*sizeof_object;
- std::size_t p_size = preferred_size*sizeof_object;
- std::size_t r_size;
+ size_type l_size = limit_size*sizeof_object;
+ size_type p_size = preferred_size*sizeof_object;
+ size_type r_size;
{
//-----------------------
boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
@@ -695,13 +747,14 @@
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
size(const void *ptr) const
{
//We need no synchronization since this block's size is not going
//to be modified by anyone else
//Obtain the real size of the block
- return (priv_get_block(ptr)->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+ return ((size_type)priv_get_block(ptr)->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
@@ -716,7 +769,7 @@
while(ib != ie){
//Just clear user the memory part reserved for the user
volatile char *ptr = reinterpret_cast<char*>(&*ib) + BlockCtrlBytes;
- std::size_t s = ib->m_size*Alignment - BlockCtrlBytes;
+ size_type s = (size_type)ib->m_size*Alignment - BlockCtrlBytes;
while(s--){
*ptr++ = 0;
}
@@ -732,12 +785,12 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
priv_expand_both_sides(boost::interprocess::allocation_type command
- ,std::size_t min_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type min_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
,bool only_preferred_backwards
- ,std::size_t backwards_multiple)
+ ,size_type backwards_multiple)
{
algo_impl_t::assert_alignment(reuse_ptr);
if(command & boost::interprocess::expand_fwd){
@@ -777,8 +830,8 @@
BOOST_ASSERT(prev_block->m_size == reuse->m_prev_size);
algo_impl_t::assert_alignment(prev_block);
- std::size_t needs_backwards_aligned;
- std::size_t lcm;
+ size_type needs_backwards_aligned;
+ size_type lcm;
if(!algo_impl_t::calculate_lcm_and_needs_backwards_lcmed
( backwards_multiple
, received_size
@@ -788,10 +841,10 @@
}
//Check if previous block has enough size
- if(std::size_t(prev_block->m_size*Alignment) >= needs_backwards_aligned){
+ if(size_type(prev_block->m_size*Alignment) >= needs_backwards_aligned){
//Now take all next space. This will succeed
if(command & boost::interprocess::expand_fwd){
- std::size_t received_size2;
+ size_type received_size2;
if(!priv_expand(reuse_ptr, received_size, received_size, received_size2)){
BOOST_ASSERT(0);
}
@@ -806,7 +859,7 @@
new_block->m_size =
AllocatedCtrlUnits + (needs_backwards_aligned + (received_size - UsableByPreviousChunk))/Alignment;
BOOST_ASSERT(new_block->m_size >= BlockCtrlUnits);
- priv_mark_new_allocated_block(new_block);
+ priv_mark_as_allocated_block(new_block);
prev_block->m_size = (reinterpret_cast<char*>(new_block) -
reinterpret_cast<char*>(prev_block))/Alignment;
@@ -849,13 +902,13 @@
//Just merge the whole previous block
//prev_block->m_size*Alignment is multiple of lcm (and backwards_multiple)
- received_size = received_size + prev_block->m_size*Alignment;
+ received_size = received_size + (size_type)prev_block->m_size*Alignment;
- m_header.m_allocated += prev_block->m_size*Alignment;
+ m_header.m_allocated += (size_type)prev_block->m_size*Alignment;
//Now update sizes
prev_block->m_size = prev_block->m_size + reuse->m_size;
BOOST_ASSERT(prev_block->m_size >= BlockCtrlUnits);
- priv_mark_new_allocated_block(prev_block);
+ priv_mark_as_allocated_block(prev_block);
//If the backwards expansion has remaining bytes in the
//first bytes, fill them with a pattern
@@ -885,11 +938,11 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
std::pair<void *, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
priv_allocate(boost::interprocess::allocation_type command
- ,std::size_t limit_size
- ,std::size_t preferred_size
- ,std::size_t &received_size
+ ,size_type limit_size
+ ,size_type preferred_size
+ ,size_type &received_size
,void *reuse_ptr
- ,std::size_t backwards_multiple)
+ ,size_type backwards_multiple)
{
//Remove me. Forbid backwards allocation
//command &= (~boost::interprocess::expand_bwd);
@@ -907,10 +960,10 @@
return return_type(static_cast<void*>(0), false);
//Number of units to request (including block_ctrl header)
- std::size_t preferred_units = priv_get_total_units(preferred_size);
+ size_type preferred_units = priv_get_total_units(preferred_size);
//Number of units to request (including block_ctrl header)
- std::size_t limit_units = priv_get_total_units(limit_size);
+ size_type limit_units = priv_get_total_units(limit_size);
//Expand in place
if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
@@ -963,13 +1016,13 @@
{ return const_cast<char*>(reinterpret_cast<const char*>(block) + AllocatedCtrlBytes); }
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
-inline
-std::size_t rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
- priv_get_total_units(std::size_t userbytes)
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+ priv_get_total_units(size_type userbytes)
{
if(userbytes < UsableByPreviousChunk)
userbytes = UsableByPreviousChunk;
- std::size_t units = detail::get_rounded_size(userbytes - UsableByPreviousChunk, Alignment)/Alignment + AllocatedCtrlUnits;
+ size_type units = detail::get_rounded_size(userbytes - UsableByPreviousChunk, Alignment)/Alignment + AllocatedCtrlUnits;
if(units < BlockCtrlUnits) units = BlockCtrlUnits;
return units;
}
@@ -977,13 +1030,13 @@
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
priv_expand (void *ptr
- ,const std::size_t min_size
- ,const std::size_t preferred_size
- ,std::size_t &received_size)
+ ,const size_type min_size
+ ,const size_type preferred_size
+ ,size_type &received_size)
{
//Obtain the real size of the block
block_ctrl *block = priv_get_block(ptr);
- std::size_t old_block_units = block->m_size;
+ size_type old_block_units = block->m_size;
//The block must be marked as allocated and the sizes must be equal
BOOST_ASSERT(priv_is_allocated_block(block));
@@ -995,8 +1048,8 @@
return true;
//Now translate it to Alignment units
- const std::size_t min_user_units = algo_impl_t::ceil_units(min_size - UsableByPreviousChunk);
- const std::size_t preferred_user_units = algo_impl_t::ceil_units(preferred_size - UsableByPreviousChunk);
+ const size_type min_user_units = algo_impl_t::ceil_units(min_size - UsableByPreviousChunk);
+ const size_type preferred_user_units = algo_impl_t::ceil_units(preferred_size - UsableByPreviousChunk);
//Some parameter checks
BOOST_ASSERT(min_user_units <= preferred_user_units);
@@ -1009,10 +1062,10 @@
algo_impl_t::assert_alignment(next_block);
//Is "block" + "next_block" big enough?
- const std::size_t merged_units = old_block_units + next_block->m_size;
+ const size_type merged_units = old_block_units + (size_type)next_block->m_size;
//Now get the expansion size
- const std::size_t merged_user_units = merged_units - AllocatedCtrlUnits;
+ const size_type merged_user_units = merged_units - AllocatedCtrlUnits;
if(merged_user_units < min_user_units){
received_size = merged_units*Alignment - UsableByPreviousChunk;
@@ -1020,11 +1073,11 @@
}
//Now get the maximum size the user can allocate
- std::size_t intended_user_units = (merged_user_units < preferred_user_units) ?
+ size_type intended_user_units = (merged_user_units < preferred_user_units) ?
merged_user_units : preferred_user_units;
//These are total units of the merged block (supposing the next block can be split)
- const std::size_t intended_units = AllocatedCtrlUnits + intended_user_units;
+ const size_type intended_units = AllocatedCtrlUnits + intended_user_units;
//Check if we can split the next one in two parts
if((merged_units - intended_units) >= BlockCtrlUnits){
@@ -1032,7 +1085,7 @@
//two blocks, the first one will be merged and
//the second's size will be the remaining space
BOOST_ASSERT(next_block->m_size == priv_next_block(next_block)->m_prev_size);
- const std::size_t rem_units = merged_units - intended_units;
+ const size_type rem_units = merged_units - intended_units;
//Check if we we need to update the old next block in the free blocks tree
//If the new size fulfills tree invariants, we just need to replace the node
@@ -1079,7 +1132,7 @@
m_header.m_allocated += (merged_units - old_block_units)*Alignment;
}
priv_mark_as_allocated_block(block);
- received_size = (block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+ received_size = ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
return true;
}
@@ -1093,37 +1146,45 @@
(reinterpret_cast<char*>(ptr) - ptr->m_prev_size*Alignment);
}
-template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
-bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_prev_allocated
- (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
-{
- if(ptr->m_prev_allocated){
- return true;
- }
- else{
- block_ctrl *prev = priv_prev_block(ptr);
- (void)prev;
- BOOST_ASSERT(!priv_is_allocated_block(prev));
- return false;
- }
-}
+
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_end_block
(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *first_segment_block)
{
+ //The first block's logic is different from the rest of blocks: stores in m_prev_size the absolute
+ //distance with the end block
BOOST_ASSERT(first_segment_block->m_prev_allocated);
block_ctrl *end_block = reinterpret_cast<block_ctrl *>
- (reinterpret_cast<char*>(first_segment_block) - first_segment_block->m_prev_size*Alignment);
+ (reinterpret_cast<char*>(first_segment_block) + first_segment_block->m_prev_size*Alignment);
(void)end_block;
- BOOST_ASSERT(priv_is_allocated_block(end_block));
+ BOOST_ASSERT(end_block->m_allocated == 1);
+ BOOST_ASSERT(end_block->m_size == first_segment_block->m_prev_size);
BOOST_ASSERT(end_block > first_segment_block);
return end_block;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+ rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_first_block
+ (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *end_segment_block)
+{
+ //The first block's logic is different from the rest of blocks: stores in m_prev_size the absolute
+ //distance with the end block
+ BOOST_ASSERT(end_segment_block->m_allocated);
+ block_ctrl *first_block = reinterpret_cast<block_ctrl *>
+ (reinterpret_cast<char*>(end_segment_block) - end_segment_block->m_size*Alignment);
+ (void)first_block;
+ BOOST_ASSERT(first_block->m_prev_allocated == 1);
+ BOOST_ASSERT(first_block->m_prev_size == end_segment_block->m_size);
+ BOOST_ASSERT(end_segment_block > first_block);
+ return first_block;
+}
+
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_next_block
(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
{
@@ -1136,19 +1197,47 @@
(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
bool allocated = block->m_allocated != 0;
- block_ctrl *next_block = reinterpret_cast<block_ctrl *>
- (reinterpret_cast<char*>(block) + block->m_size*Alignment);
- bool next_block_prev_allocated = next_block->m_prev_allocated != 0;
- (void)next_block_prev_allocated;
- BOOST_ASSERT(allocated == next_block_prev_allocated);
+ #ifndef NDEBUG
+ if(block != priv_end_block()){
+ block_ctrl *next_block = reinterpret_cast<block_ctrl *>
+ (reinterpret_cast<char*>(block) + block->m_size*Alignment);
+ bool next_block_prev_allocated = next_block->m_prev_allocated != 0;
+ (void)next_block_prev_allocated;
+ BOOST_ASSERT(allocated == next_block_prev_allocated);
+ }
+ else{
+ block = block;
+ }
+ #endif
return allocated;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_prev_allocated
+ (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{
+ if(block->m_prev_allocated){
+ return true;
+ }
+ else{
+ #ifndef NDEBUG
+ if(block != priv_first_block()){
+ block_ctrl *prev = priv_prev_block(block);
+ (void)prev;
+ BOOST_ASSERT(!prev->m_allocated);
+ }
+ else{
+ block = block;
+ }
+ #endif
+ return false;
+ }
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_mark_as_allocated_block
(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
- //BOOST_ASSERT(!priv_is_allocated_block(block));
block->m_allocated = 1;
reinterpret_cast<block_ctrl *>
(reinterpret_cast<char*>(block)+ block->m_size*Alignment)->m_prev_allocated = 1;
@@ -1159,19 +1248,18 @@
(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
block->m_allocated = 0;
- reinterpret_cast<block_ctrl *>
- (reinterpret_cast<char*>(block) + block->m_size*Alignment)->m_prev_allocated = 0;
- //BOOST_ASSERT(!priv_is_allocated_block(ptr));
- priv_next_block(block)->m_prev_size = block->m_size;
+ block_ctrl *next_block = priv_next_block(block);
+ next_block->m_prev_allocated = 0;
+ next_block->m_prev_size = block->m_size;
}
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_check_and_allocate
- (std::size_t nunits
+ (size_type nunits
,typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl* block
- ,std::size_t &received_size)
+ ,size_type &received_size)
{
- std::size_t upper_nunits = nunits + BlockCtrlUnits;
+ size_type upper_nunits = nunits + BlockCtrlUnits;
imultiset_iterator it_old = Imultiset::s_iterator_to(*block);
algo_impl_t::assert_alignment(block);
@@ -1179,7 +1267,7 @@
//This block is bigger than needed, split it in
//two blocks, the first's size will be "units" and
//the second's size "block->m_size-units"
- std::size_t block_old_size = block->m_size;
+ size_type block_old_size = block->m_size;
block->m_size = nunits;
BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
@@ -1218,8 +1306,8 @@
}
//We need block_ctrl for deallocation stuff, so
//return memory user can overwrite
- m_header.m_allocated += block->m_size*Alignment;
- received_size = (block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+ m_header.m_allocated += (size_type)block->m_size*Alignment;
+ received_size = ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
//Mark the block as allocated
priv_mark_as_allocated_block(block);
@@ -1232,10 +1320,6 @@
//volatile char *ptr =
char *ptr = reinterpret_cast<char*>(block)+tree_hook_offset_in_block;
const std::size_t s = BlockCtrlBytes - tree_hook_offset_in_block;
- /*
- while(s--){
- *ptr++ = 0;
- }*/
std::memset(ptr, 0, s);
this->priv_next_block(block)->m_prev_size = 0;
return priv_get_user_buffer(block);
@@ -1265,7 +1349,7 @@
//Check if alignment and block size are right
algo_impl_t::assert_alignment(addr);
- std::size_t block_old_size = Alignment*block->m_size;
+ size_type block_old_size = Alignment*(size_type)block->m_size;
BOOST_ASSERT(m_header.m_allocated >= block_old_size);
//Update used memory count
Modified: trunk/boost/interprocess/mem_algo/simple_seq_fit.hpp
==============================================================================
--- trunk/boost/interprocess/mem_algo/simple_seq_fit.hpp (original)
+++ trunk/boost/interprocess/mem_algo/simple_seq_fit.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -39,10 +39,12 @@
/// @endcond
public:
+ typedef typename base_t::size_type size_type;
+
//!Constructor. "size" is the total size of the managed memory segment,
//!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit)
//!offset that the allocator should not use at all.*/
- simple_seq_fit (std::size_t size, std::size_t extra_hdr_bytes)
+ simple_seq_fit (size_type size, size_type extra_hdr_bytes)
: base_t(size, extra_hdr_bytes){}
};
Modified: trunk/boost/interprocess/offset_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/offset_ptr.hpp (original)
+++ trunk/boost/interprocess/offset_ptr.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -23,11 +23,14 @@
#include <boost/interprocess/detail/cast_tags.hpp>
#include <boost/interprocess/detail/mpl.hpp>
#include <boost/pointer_cast.hpp>
+#include <boost/pointer_to_other.hpp>
#include <boost/assert.hpp>
#include <boost/assert.hpp>
#include <ostream>
#include <istream>
#include <iterator>
+#include <boost/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
//!\file
//!Describes a smart pointer that stores the offset between this pointer and
@@ -50,45 +53,70 @@
//!pointer and the pointee are still separated by the same offset. This feature
//!converts offset_ptr in a smart pointer that can be placed in shared memory and
//!memory mapped files mapped in different addresses in every process.
-template <class PointedType>
+template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
class offset_ptr
{
/// @cond
- typedef offset_ptr<PointedType> self_t;
+ typedef offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment> self_t;
void unspecified_bool_type_func() const {}
typedef void (self_t::*unspecified_bool_type)() const;
+ //Note: using the address of a local variable to point to another address
+ //is not standard conforming and this can be optimized-away by the compiler.
+ //Non-inlining is a method to remain illegal and correct
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
- __declspec(noinline) //this workaround is needed for msvc > 8.0
+ __declspec(noinline) //this workaround is needed for msvc-8.0 and msvc-9.0
+ #elif defined (__GNUC__)//this workaround is needed for GCC
+ __attribute__((noinline))
#endif
void set_offset(const PointedType *ptr)
{
+ #if defined (__GNUC__)
+ asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
+ #endif
//offset == 1 && ptr != 0 is not legal for this pointer
if(!ptr){
internal.m_offset = 1;
}
else{
- internal.m_offset = (const char*)ptr - (const char*)(this);
+ internal.m_offset = (OffsetType)((const char*)ptr - (const char*)(this));
BOOST_ASSERT(internal.m_offset != 1);
}
}
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
- __declspec(noinline) //this workaround is needed for msvc-8.0 and msvc-9.0
+ __declspec(noinline)
+ #elif defined (__GNUC__)
+ __attribute__((noinline))
#endif
- void* get_pointer() const
- { return (internal.m_offset == 1) ? 0 : (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset); }
+ PointedType * get_pointer() const
+ {
+ #if defined (__GNUC__)
+ asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
+ #endif
+ return static_cast<PointedType *>(
+ static_cast<void*>(
+ (internal.m_offset == 1) ?
+ 0 :
+ (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset)
+ )
+ );
+ }
- void inc_offset(std::ptrdiff_t bytes)
+ void inc_offset(DifferenceType bytes)
{ internal.m_offset += bytes; }
- void dec_offset(std::ptrdiff_t bytes)
+ void dec_offset(DifferenceType bytes)
{ internal.m_offset -= bytes; }
union internal_type{
- std::ptrdiff_t m_offset; //Distance between this object and pointed address
- PointedType *aliasing_helper;
+ OffsetType m_offset; //Distance between this object and pointed address
+/* typename ::boost::aligned_storage
+ < sizeof(OffsetType)
+ , (OffsetAlignment == offset_type_alignment) ?
+ ::boost::alignment_of<OffsetType>::value : OffsetAlignment
+ >::type alignment_helper;*/
} internal;
/// @endcond
@@ -97,8 +125,9 @@
typedef typename detail::
add_reference<PointedType>::type reference;
typedef PointedType value_type;
- typedef std::ptrdiff_t difference_type;
+ typedef DifferenceType difference_type;
typedef std::random_access_iterator_tag iterator_category;
+ typedef OffsetType offset_type;
public: //Public Functions
@@ -119,40 +148,40 @@
//!Constructor from other offset_ptr. If pointers of pointee types are
//!convertible, offset_ptrs will be convertibles. Never throws.
- template<class T2>
- offset_ptr(const offset_ptr<T2> &ptr)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr(const offset_ptr<T2, P2, O2, A2> &ptr)
{ pointer p(ptr.get()); (void)p; this->set_offset(p); }
//!Emulates static_cast operator.
//!Never throws.
- template<class Y>
- offset_ptr(const offset_ptr<Y> & r, detail::static_cast_tag)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, detail::static_cast_tag)
{ this->set_offset(static_cast<PointedType*>(r.get())); }
//!Emulates const_cast operator.
//!Never throws.
- template<class Y>
- offset_ptr(const offset_ptr<Y> & r, detail::const_cast_tag)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, detail::const_cast_tag)
{ this->set_offset(const_cast<PointedType*>(r.get())); }
//!Emulates dynamic_cast operator.
//!Never throws.
- template<class Y>
- offset_ptr(const offset_ptr<Y> & r, detail::dynamic_cast_tag)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, detail::dynamic_cast_tag)
{ this->set_offset(dynamic_cast<PointedType*>(r.get())); }
//!Emulates reinterpret_cast operator.
//!Never throws.
- template<class Y>
- offset_ptr(const offset_ptr<Y> & r, detail::reinterpret_cast_tag)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, detail::reinterpret_cast_tag)
{ this->set_offset(reinterpret_cast<PointedType*>(r.get())); }
//!Obtains raw pointer from offset.
//!Never throws.
pointer get()const
- { return static_cast<pointer>(this->get_pointer()); }
+ { return this->get_pointer(); }
- std::ptrdiff_t get_offset() const
+ offset_type get_offset() const
{ return internal.m_offset; }
//!Pointer-like -> operator. It can return 0 pointer.
@@ -171,7 +200,8 @@
//!Indexing operator.
//!Never throws.
- reference operator[](std::ptrdiff_t idx) const
+ template<class T>
+ reference operator[](T idx) const
{ return this->get()[idx]; }
//!Assignment from pointer (saves extra conversion).
@@ -186,28 +216,32 @@
//!Assignment from related offset_ptr. If pointers of pointee types
//! are assignable, offset_ptrs will be assignable. Never throws.
- template <class T2>
- offset_ptr& operator= (const offset_ptr<T2> & pt)
+ template<class T2, class P2, class O2, std::size_t A2>
+ offset_ptr& operator= (const offset_ptr<T2, P2, O2, A2> & pt)
{ pointer p(pt.get()); this->set_offset(p); return *this; }
- //!offset_ptr + std::ptrdiff_t.
+ //!offset_ptr + difference_type.
//!Never throws.
- offset_ptr operator+ (std::ptrdiff_t offset) const
+ template<class T>
+ offset_ptr operator+ (T offset) const
{ return offset_ptr(this->get()+offset); }
- //!offset_ptr - std::ptrdiff_t.
+ //!offset_ptr - difference_type.
//!Never throws.
- offset_ptr operator- (std::ptrdiff_t offset) const
+ template<class T>
+ offset_ptr operator- (T offset) const
{ return offset_ptr(this->get()-offset); }
- //!offset_ptr += std::ptrdiff_t.
+ //!offset_ptr += difference_type.
//!Never throws.
- offset_ptr &operator+= (std::ptrdiff_t offset)
+ template<class T>
+ offset_ptr &operator+= (T offset)
{ this->inc_offset(offset * sizeof (PointedType)); return *this; }
- //!offset_ptr -= std::ptrdiff_t.
+ //!offset_ptr -= difference_type.
//!Never throws.
- offset_ptr &operator-= (std::ptrdiff_t offset)
+ template<class T>
+ offset_ptr &operator-= (T offset)
{ this->dec_offset(offset * sizeof (PointedType)); return *this; }
//!++offset_ptr.
@@ -249,118 +283,119 @@
*/
};
-//!offset_ptr<T1> == offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> == offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator== (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator== (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() == pt2.get(); }
-//!offset_ptr<T1> != offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> != offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator!= (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator!= (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() != pt2.get(); }
-//!offset_ptr<T1> < offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> < offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator< (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator< (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() < pt2.get(); }
-//!offset_ptr<T1> <= offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> <= offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator<= (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator<= (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() <= pt2.get(); }
-//!offset_ptr<T1> > offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> > offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator> (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator> (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() > pt2.get(); }
-//!offset_ptr<T1> >= offset_ptr<T2>.
+//!offset_ptr<T1, P1, O1, A1> >= offset_ptr<T2, P2, O2, A2>.
//!Never throws.
-template<class T1, class T2>
-inline bool operator>= (const offset_ptr<T1> &pt1,
- const offset_ptr<T2> &pt2)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline bool operator>= (const offset_ptr<T1, P1, O1, A1> &pt1,
+ const offset_ptr<T2, P2, O2, A2> &pt2)
{ return pt1.get() >= pt2.get(); }
//!operator<<
//!for offset ptr
-template<class E, class T, class Y>
+template<class E, class T, class W, class X, class Y, std::size_t Z>
inline std::basic_ostream<E, T> & operator<<
- (std::basic_ostream<E, T> & os, offset_ptr<Y> const & p)
+ (std::basic_ostream<E, T> & os, offset_ptr<W, X, Y, Z> const & p)
{ return os << p.get_offset(); }
//!operator>>
//!for offset ptr
-template<class E, class T, class Y>
+template<class E, class T, class W, class X, class Y, std::size_t Z>
inline std::basic_istream<E, T> & operator>>
- (std::basic_istream<E, T> & is, offset_ptr<Y> & p)
+ (std::basic_istream<E, T> & is, offset_ptr<W, X, Y, Z> & p)
{ return is >> p.get_offset(); }
-//!std::ptrdiff_t + offset_ptr
+//!difference_type + offset_ptr
//!operation
-template<class T>
-inline offset_ptr<T> operator+(std::ptrdiff_t diff, const offset_ptr<T>& right)
+template<class T, class P, class O, std::size_t A, class D>
+inline offset_ptr<T, P, O, A> operator+(D diff, const offset_ptr<T, P, O, A>& right)
{ return right + diff; }
//!offset_ptr - offset_ptr
//!operation
-template<class T, class T2>
-inline std::ptrdiff_t operator- (const offset_ptr<T> &pt, const offset_ptr<T2> &pt2)
-{ return pt.get()- pt2.get(); }
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline typename offset_ptr<T1, P1, O1, A1>::difference_type operator-
+ (const offset_ptr<T1, P1, O1, A1> &pt, const offset_ptr<T2, P2, O2, A2> &pt2)
+{ return typename offset_ptr<T1, P1, O1, A1>::difference_type(pt.get()- pt2.get()); }
//!swap specialization
//!for offset_ptr
-template<class T>
-inline void swap (boost::interprocess::offset_ptr<T> &pt,
- boost::interprocess::offset_ptr<T> &pt2)
+template<class T, class P, class O, std::size_t A>
+inline void swap (boost::interprocess::offset_ptr<T, P, O, A> &pt,
+ boost::interprocess::offset_ptr<T, P, O, A> &pt2)
{
- typename offset_ptr<T>::value_type *ptr = pt.get();
+ typename offset_ptr<T, P, O, A>::value_type *ptr = pt.get();
pt = pt2;
pt2 = ptr;
}
//!Simulation of static_cast between pointers. Never throws.
-template<class T, class U>
-inline boost::interprocess::offset_ptr<T>
- static_pointer_cast(const boost::interprocess::offset_ptr<U> & r)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+ static_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
- return boost::interprocess::offset_ptr<T>
+ return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::detail::static_cast_tag());
}
//!Simulation of const_cast between pointers. Never throws.
-template<class T, class U>
-inline boost::interprocess::offset_ptr<T>
- const_pointer_cast(const boost::interprocess::offset_ptr<U> & r)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+ const_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
- return boost::interprocess::offset_ptr<T>
+ return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::detail::const_cast_tag());
}
//!Simulation of dynamic_cast between pointers. Never throws.
-template<class T, class U>
-inline boost::interprocess::offset_ptr<T>
- dynamic_pointer_cast(const boost::interprocess::offset_ptr<U> & r)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+ dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
- return boost::interprocess::offset_ptr<T>
+ return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::detail::dynamic_cast_tag());
}
//!Simulation of reinterpret_cast between pointers. Never throws.
-template<class T, class U>
-inline boost::interprocess::offset_ptr<T>
- reinterpret_pointer_cast(const boost::interprocess::offset_ptr<U> & r)
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+ reinterpret_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
- return boost::interprocess::offset_ptr<T>
+ return boost::interprocess::offset_ptr<T1, P1, O1, A1>
(r, boost::interprocess::detail::reinterpret_cast_tag());
}
@@ -369,15 +404,15 @@
/// @cond
//!has_trivial_constructor<> == true_type specialization for optimizations
-template <class T>
-struct has_trivial_constructor< boost::interprocess::offset_ptr<T> >
+template <class T, class P, class O, std::size_t A>
+struct has_trivial_constructor< boost::interprocess::offset_ptr<T, P, O, A> >
{
enum { value = true };
};
///has_trivial_destructor<> == true_type specialization for optimizations
-template <class T>
-struct has_trivial_destructor< boost::interprocess::offset_ptr<T> >
+template <class T, class P, class O, std::size_t A>
+struct has_trivial_destructor< boost::interprocess::offset_ptr<T, P, O, A> >
{
enum { value = true };
};
@@ -387,8 +422,8 @@
//#endif
//!get_pointer() enables boost::mem_fn to recognize offset_ptr.
//!Never throws.
-template<class T>
-inline T * get_pointer(boost::interprocess::offset_ptr<T> const & p)
+template <class T, class P, class O, std::size_t A>
+inline T * get_pointer(boost::interprocess::offset_ptr<T, P, O, A> const & p)
{ return p.get(); }
//#if !defined(_MSC_VER) || (_MSC_VER >= 1400)
} //namespace interprocess
@@ -409,22 +444,22 @@
template<class VoidPointer, std::size_t N>
struct max_pointer_plus_bits;
-template<std::size_t Alignment>
-struct max_pointer_plus_bits<boost::interprocess::offset_ptr<void>, Alignment>
+template<std::size_t OffsetAlignment, class P, class O, std::size_t A>
+struct max_pointer_plus_bits<boost::interprocess::offset_ptr<void, P, O, A>, OffsetAlignment>
{
//The offset ptr can embed one bit less than the alignment since it
//uses offset == 1 to store the null pointer.
- static const std::size_t value = ::boost::interprocess::detail::ls_zeros<Alignment>::value - 1;
+ static const std::size_t value = ::boost::interprocess::detail::ls_zeros<OffsetAlignment>::value - 1;
};
//Predeclaration
template<class Pointer, std::size_t NumBits>
struct pointer_plus_bits;
-template<class T, std::size_t NumBits>
-struct pointer_plus_bits<boost::interprocess::offset_ptr<T>, NumBits>
+template<class T, class P, class O, std::size_t A, std::size_t NumBits>
+struct pointer_plus_bits<boost::interprocess::offset_ptr<T, P, O, A>, NumBits>
{
- typedef boost::interprocess::offset_ptr<T> pointer;
+ typedef boost::interprocess::offset_ptr<T, P, O, A> pointer;
//Bits are stored in the lower bits of the pointer except the LSB,
//because this bit is used to represent the null pointer.
static const std::size_t Mask = ((std::size_t(1) << NumBits)-1)<<1u;
@@ -450,6 +485,13 @@
};
} //namespace intrusive
+
+template<class T, class T2, class T3, std::size_t A, class U>
+struct pointer_to_other< ::boost::interprocess::offset_ptr<T, T2, T3, A>, U >
+{
+ typedef ::boost::interprocess::offset_ptr<U, T2, T3, A> type;
+};
+
} //namespace boost{
/// @endcond
Modified: trunk/boost/interprocess/segment_manager.hpp
==============================================================================
--- trunk/boost/interprocess/segment_manager.hpp (original)
+++ trunk/boost/interprocess/segment_manager.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -74,12 +74,14 @@
//Experimental. Don't use
typedef typename MemoryAlgorithm::multiallocation_chain multiallocation_chain;
+ typedef typename MemoryAlgorithm::difference_type difference_type;
+ typedef typename MemoryAlgorithm::size_type size_type;
/// @endcond
//!This constant indicates the payload size
//!associated with each allocation of the memory algorithm
- static const std::size_t PayloadPerAllocation = MemoryAlgorithm::PayloadPerAllocation;
+ static const size_type PayloadPerAllocation = MemoryAlgorithm::PayloadPerAllocation;
//!Constructor of the segment_manager_base
//!
@@ -92,7 +94,7 @@
//!dynamic allocation
//!
//!Can throw
- segment_manager_base(std::size_t size, std::size_t reserved_bytes)
+ segment_manager_base(size_type size, size_type reserved_bytes)
: MemoryAlgorithm(size, reserved_bytes)
{
BOOST_ASSERT((sizeof(segment_manager_base<MemoryAlgorithm>) == sizeof(MemoryAlgorithm)));
@@ -100,22 +102,22 @@
//!Returns the size of the memory
//!segment
- std::size_t get_size() const
+ size_type get_size() const
{ return MemoryAlgorithm::get_size(); }
//!Returns the number of free bytes of the memory
//!segment
- std::size_t get_free_memory() const
+ size_type get_free_memory() const
{ return MemoryAlgorithm::get_free_memory(); }
//!Obtains the minimum size needed by
//!the segment manager
- static std::size_t get_min_size (std::size_t size)
+ static size_type get_min_size (size_type size)
{ return MemoryAlgorithm::get_min_size(size); }
//!Allocates nbytes bytes. This function is only used in
//!single-segment management. Never throws
- void * allocate (std::size_t nbytes, std::nothrow_t)
+ void * allocate (size_type nbytes, std::nothrow_t)
{ return MemoryAlgorithm::allocate(nbytes); }
/// @cond
@@ -123,7 +125,7 @@
//Experimental. Dont' use.
//!Allocates n_elements of
//!elem_size bytes. Throws bad_alloc on failure.
- multiallocation_chain allocate_many(std::size_t elem_bytes, std::size_t num_elements)
+ multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
{
multiallocation_chain mem(MemoryAlgorithm::allocate_many(elem_bytes, num_elements));
if(mem.empty()) throw bad_alloc();
@@ -133,7 +135,7 @@
//!Allocates n_elements, each one of
//!element_lenghts[i]*sizeof_element bytes. Throws bad_alloc on failure.
multiallocation_chain allocate_many
- (const std::size_t *element_lenghts, std::size_t n_elements, std::size_t sizeof_element = 1)
+ (const size_type *element_lenghts, size_type n_elements, size_type sizeof_element = 1)
{
multiallocation_chain mem(MemoryAlgorithm::allocate_many(element_lenghts, n_elements, sizeof_element));
if(mem.empty()) throw bad_alloc();
@@ -143,14 +145,14 @@
//!Allocates n_elements of
//!elem_size bytes. Returns a default constructed iterator on failure.
multiallocation_chain allocate_many
- (std::size_t elem_bytes, std::size_t num_elements, std::nothrow_t)
+ (size_type elem_bytes, size_type num_elements, std::nothrow_t)
{ return MemoryAlgorithm::allocate_many(elem_bytes, num_elements); }
//!Allocates n_elements, each one of
//!element_lenghts[i]*sizeof_element bytes.
//!Returns a default constructed iterator on failure.
multiallocation_chain allocate_many
- (const std::size_t *elem_sizes, std::size_t n_elements, std::size_t sizeof_element, std::nothrow_t)
+ (const size_type *elem_sizes, size_type n_elements, size_type sizeof_element, std::nothrow_t)
{ return MemoryAlgorithm::allocate_many(elem_sizes, n_elements, sizeof_element); }
//!Deallocates elements pointed by the
@@ -162,7 +164,7 @@
//!Allocates nbytes bytes. Throws boost::interprocess::bad_alloc
//!on failure
- void * allocate(std::size_t nbytes)
+ void * allocate(size_type nbytes)
{
void * ret = MemoryAlgorithm::allocate(nbytes);
if(!ret)
@@ -172,12 +174,12 @@
//!Allocates nbytes bytes. This function is only used in
//!single-segment management. Never throws
- void * allocate_aligned (std::size_t nbytes, std::size_t alignment, std::nothrow_t)
+ void * allocate_aligned (size_type nbytes, size_type alignment, std::nothrow_t)
{ return MemoryAlgorithm::allocate_aligned(nbytes, alignment); }
//!Allocates nbytes bytes. This function is only used in
//!single-segment management. Throws bad_alloc when fails
- void * allocate_aligned(std::size_t nbytes, std::size_t alignment)
+ void * allocate_aligned(size_type nbytes, size_type alignment)
{
void * ret = MemoryAlgorithm::allocate_aligned(nbytes, alignment);
if(!ret)
@@ -187,8 +189,8 @@
template<class T>
std::pair<T *, bool>
- allocation_command (boost::interprocess::allocation_type command, std::size_t limit_size,
- std::size_t preferred_size,std::size_t &received_size,
+ allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
+ size_type preferred_size,size_type &received_size,
T *reuse_ptr = 0)
{
std::pair<T *, bool> ret = MemoryAlgorithm::allocation_command
@@ -200,9 +202,9 @@
}
std::pair<void *, bool>
- raw_allocation_command (boost::interprocess::allocation_type command, std::size_t limit_objects,
- std::size_t preferred_objects,std::size_t &received_objects,
- void *reuse_ptr = 0, std::size_t sizeof_object = 1)
+ raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects,
+ size_type preferred_objects,size_type &received_objects,
+ void *reuse_ptr = 0, size_type sizeof_object = 1)
{
std::pair<void *, bool> ret = MemoryAlgorithm::raw_allocation_command
( command | boost::interprocess::nothrow_allocation, limit_objects, preferred_objects, received_objects
@@ -219,7 +221,7 @@
//!Increases managed memory in extra_size bytes more. This only works
//!with single-segment management.
- void grow(std::size_t extra_size)
+ void grow(size_type extra_size)
{ MemoryAlgorithm::grow(extra_size); }
//!Decreases managed memory to the minimum. This only works
@@ -243,17 +245,17 @@
{ MemoryAlgorithm::zero_free_memory(); }
//!Returns the size of the buffer previously allocated pointed by ptr
- std::size_t size(const void *ptr) const
+ size_type size(const void *ptr) const
{ return MemoryAlgorithm::size(ptr); }
/// @cond
protected:
void * prot_anonymous_construct
- (std::size_t num, bool dothrow, detail::in_place_interface &table)
+ (size_type num, bool dothrow, detail::in_place_interface &table)
{
- typedef detail::block_header block_header_t;
- block_header_t block_info ( table.size*num
- , table.alignment
+ typedef detail::block_header<size_type> block_header_t;
+ block_header_t block_info ( size_type(table.size*num)
+ , size_type(table.alignment)
, anonymous_type
, 1
, 0);
@@ -292,7 +294,7 @@
{
//Get control data from associated with this object
- typedef detail::block_header block_header_t;
+ typedef detail::block_header<size_type> block_header_t;
block_header_t *ctrl_data = block_header_t::block_header_from_value(object, table.size, table.alignment);
//-------------------------------
@@ -307,7 +309,7 @@
//Call destructors and free memory
//Build scoped ptr to avoid leaks with destructor exception
std::size_t destroyed = 0;
- table.destroy_n(const_cast<void*>(object), ctrl_data->m_value_bytes/table.size, destroyed);
+ table.destroy_n(const_cast<void*>(object), ctrl_data->m_value_bytes/table.size, destroyed);
this->deallocate(ctrl_data);
}
/// @endcond
@@ -341,20 +343,22 @@
segment_manager(const segment_manager &);
segment_manager &operator=(const segment_manager &);
typedef segment_manager_base<MemoryAlgorithm> Base;
- typedef detail::block_header block_header_t;
/// @endcond
public:
typedef MemoryAlgorithm memory_algorithm;
typedef typename Base::void_pointer void_pointer;
+ typedef typename Base::size_type size_type;
+ typedef typename Base::difference_type difference_type;
typedef CharType char_type;
typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type;
- static const std::size_t PayloadPerAllocation = Base::PayloadPerAllocation;
+ static const size_type PayloadPerAllocation = Base::PayloadPerAllocation;
/// @cond
private:
+ typedef detail::block_header<size_type> block_header_t;
typedef detail::index_config<CharType, MemoryAlgorithm> index_config_named;
typedef detail::index_config<char, MemoryAlgorithm> index_config_unique;
typedef IndexType<index_config_named> index_type;
@@ -403,7 +407,7 @@
//!"size" is the size of the memory segment where
//!the segment manager is being constructed.
//!Can throw
- segment_manager(std::size_t size)
+ segment_manager(size_type size)
: Base(size, priv_get_reserved_bytes())
, m_header(static_cast<Base*>(get_this_pointer()))
{
@@ -415,28 +419,28 @@
//!and the object count. On failure the first member of the
//!returned pair is 0.
template <class T>
- std::pair<T*, std::size_t> find (const CharType* name)
+ std::pair<T*, size_type> find (const CharType* name)
{ return this->priv_find_impl<T>(name, true); }
//!Tries to find a previous unique allocation. Returns the address
//!and the object count. On failure the first member of the
//!returned pair is 0.
template <class T>
- std::pair<T*, std::size_t> find (const detail::unique_instance_t* name)
+ std::pair<T*, size_type> find (const detail::unique_instance_t* name)
{ return this->priv_find_impl<T>(name, true); }
//!Tries to find a previous named allocation. Returns the address
//!and the object count. On failure the first member of the
//!returned pair is 0. This search is not mutex-protected!
template <class T>
- std::pair<T*, std::size_t> find_no_lock (const CharType* name)
+ std::pair<T*, size_type> find_no_lock (const CharType* name)
{ return this->priv_find_impl<T>(name, false); }
//!Tries to find a previous unique allocation. Returns the address
//!and the object count. On failure the first member of the
//!returned pair is 0. This search is not mutex-protected!
template <class T>
- std::pair<T*, std::size_t> find_no_lock (const detail::unique_instance_t* name)
+ std::pair<T*, size_type> find_no_lock (const detail::unique_instance_t* name)
{ return this->priv_find_impl<T>(name, false); }
//!Returns throwing "construct" proxy
@@ -558,7 +562,7 @@
//!Returns the length of an object created with construct/find_or_construct
//!functions. Does not throw.
template<class T>
- static std::size_t get_instance_length(const T *ptr)
+ static size_type get_instance_length(const T *ptr)
{ return priv_get_instance_length(block_header_t::block_header_from_value(ptr), sizeof(T)); }
//!Returns is the the name of an object created with construct/find_or_construct
@@ -570,7 +574,7 @@
//!Preallocates needed index resources to optimize the
//!creation of "num" named objects in the managed memory segment.
//!Can throw boost::interprocess::bad_alloc if there is no enough memory.
- void reserve_named_objects(std::size_t num)
+ void reserve_named_objects(size_type num)
{
//-------------------------------
scoped_lock<rmutex> guard(m_header);
@@ -581,7 +585,7 @@
//!Preallocates needed index resources to optimize the
//!creation of "num" unique objects in the managed memory segment.
//!Can throw boost::interprocess::bad_alloc if there is no enough memory.
- void reserve_unique_objects(std::size_t num)
+ void reserve_unique_objects(size_type num)
{
//-------------------------------
scoped_lock<rmutex> guard(m_header);
@@ -602,7 +606,7 @@
//!Returns the number of named objects stored in
//!the segment.
- std::size_t get_num_named_objects()
+ size_type get_num_named_objects()
{
//-------------------------------
scoped_lock<rmutex> guard(m_header);
@@ -612,7 +616,7 @@
//!Returns the number of unique objects stored in
//!the segment.
- std::size_t get_num_unique_objects()
+ size_type get_num_unique_objects()
{
//-------------------------------
scoped_lock<rmutex> guard(m_header);
@@ -622,7 +626,7 @@
//!Obtains the minimum size needed by the
//!segment manager
- static std::size_t get_min_size()
+ static size_type get_min_size()
{ return Base::get_min_size(priv_get_reserved_bytes()); }
//!Returns a constant iterator to the beginning of the information about
@@ -694,7 +698,7 @@
//!encapsulated in an object function.
template<class T>
T *generic_construct(const CharType *name,
- std::size_t num,
+ size_type num,
bool try2find,
bool dothrow,
detail::in_place_interface &table)
@@ -708,12 +712,12 @@
//!and the object count. On failure the first member of the
//!returned pair is 0.
template <class T>
- std::pair<T*, std::size_t> priv_find_impl (const CharType* name, bool lock)
+ std::pair<T*, size_type> priv_find_impl (const CharType* name, bool lock)
{
//The name can't be null, no anonymous object can be found by name
BOOST_ASSERT(name != 0);
detail::placement_destroy<T> table;
- std::size_t size;
+ size_type size;
void *ret;
if(name == reinterpret_cast<const CharType*>(-1)){
@@ -722,30 +726,30 @@
else{
ret = priv_generic_find<CharType> (name, m_header.m_named_index, table, size, is_intrusive_t(), lock);
}
- return std::pair<T*, std::size_t>(static_cast<T*>(ret), size);
+ return std::pair<T*, size_type>(static_cast<T*>(ret), size);
}
//!Tries to find a previous unique allocation. Returns the address
//!and the object count. On failure the first member of the
//!returned pair is 0.
template <class T>
- std::pair<T*, std::size_t> priv_find__impl (const detail::unique_instance_t* name, bool lock)
+ std::pair<T*, size_type> priv_find__impl (const detail::unique_instance_t* name, bool lock)
{
detail::placement_destroy<T> table;
- std::size_t size;
+ size_type size;
void *ret = priv_generic_find<char>(name, m_header.m_unique_index, table, size, is_intrusive_t(), lock);
- return std::pair<T*, std::size_t>(static_cast<T*>(ret), size);
+ return std::pair<T*, size_type>(static_cast<T*>(ret), size);
}
void *priv_generic_construct(const CharType *name,
- std::size_t num,
+ size_type num,
bool try2find,
bool dothrow,
detail::in_place_interface &table)
{
void *ret;
//Security overflow check
- if(num > ((std::size_t)-1)/table.size){
+ if(num > ((std::size_t)-1)/table.size){
if(dothrow)
throw bad_alloc();
else
@@ -808,7 +812,7 @@
return name;
}
- static std::size_t priv_get_instance_length(block_header_t *ctrl_data, std::size_t sizeofvalue)
+ static size_type priv_get_instance_length(block_header_t *ctrl_data, size_type sizeofvalue)
{
//Get header
BOOST_ASSERT((ctrl_data->value_bytes() %sizeofvalue) == 0);
@@ -824,7 +828,7 @@
return (instance_type)ctrl_data->alloc_type();
}
- static std::size_t priv_get_reserved_bytes()
+ static size_type priv_get_reserved_bytes()
{
//Get the number of bytes until the end of (*this)
//beginning in the end of the Base base.
@@ -836,7 +840,7 @@
(const CharT* name,
IndexType<detail::index_config<CharT, MemoryAlgorithm> > &index,
detail::in_place_interface &table,
- std::size_t &length,
+ size_type &length,
detail::true_ is_intrusive,
bool use_lock)
{
@@ -876,7 +880,7 @@
(const CharT* name,
IndexType<detail::index_config<CharT, MemoryAlgorithm> > &index,
detail::in_place_interface &table,
- std::size_t &length,
+ size_type &length,
detail::false_ is_intrusive,
bool use_lock)
{
@@ -920,7 +924,7 @@
(void)is_node_index;
typedef typename IndexType<detail::index_config<CharT, MemoryAlgorithm> >::iterator index_it;
- index_it *ihdr = block_header_t::to_first_header<index_it>(block_header);
+ index_it *ihdr = block_header_t::template to_first_header<index_it>(block_header);
return this->priv_generic_named_destroy_impl<CharT>(*ihdr, index, table);
}
@@ -967,7 +971,7 @@
intrusive_value_type *iv = intrusive_value_type::get_intrusive_value_type(ctrl_data);
void *memory = iv;
void *values = ctrl_data->value();
- std::size_t num = ctrl_data->m_value_bytes/table.size;
+ std::size_t num = ctrl_data->m_value_bytes/table.size;
//Sanity check
BOOST_ASSERT((ctrl_data->m_value_bytes % table.size) == 0);
@@ -1031,7 +1035,7 @@
//Check if the distance between the name pointer and the memory pointer
//is correct (this can detect incorrect type in destruction)
- std::size_t num = ctrl_data->m_value_bytes/table.size;
+ std::size_t num = ctrl_data->m_value_bytes/table.size;
void *values = ctrl_data->value();
//Sanity check
@@ -1047,7 +1051,7 @@
void *memory;
if(is_node_index_t::value){
- index_it *ihdr = block_header_t::
+ index_it *ihdr = block_header_t::template
to_first_header<index_it>(ctrl_data);
ihdr->~index_it();
memory = ihdr;
@@ -1057,16 +1061,16 @@
}
//Call destructors and free memory
- std::size_t destroyed;
+ std::size_t destroyed;
table.destroy_n(values, num, destroyed);
this->deallocate(memory);
return true;
}
template<class CharT>
- void * priv_generic_named_construct(std::size_t type,
+ void * priv_generic_named_construct(unsigned char type,
const CharT *name,
- std::size_t num,
+ size_type num,
bool try2find,
bool dothrow,
detail::in_place_interface &table,
@@ -1074,10 +1078,10 @@
detail::true_ is_intrusive)
{
(void)is_intrusive;
- std::size_t namelen = std::char_traits<CharT>::length(name);
+ std::size_t namelen = std::char_traits<CharT>::length(name);
- block_header_t block_info ( table.size*num
- , table.alignment
+ block_header_t block_info ( size_type(table.size*num)
+ , size_type(table.alignment)
, type
, sizeof(CharT)
, namelen);
@@ -1139,11 +1143,11 @@
//Check if there is enough memory
if(dothrow){
buffer_ptr = this->allocate
- (block_info.total_size_with_header<intrusive_value_type>());
+ (block_info.template total_size_with_header<intrusive_value_type>());
}
else{
buffer_ptr = this->allocate
- (block_info.total_size_with_header<intrusive_value_type>(), std::nothrow_t());
+ (block_info.template total_size_with_header<intrusive_value_type>(), std::nothrow_t());
if(!buffer_ptr)
return 0;
}
@@ -1193,9 +1197,9 @@
//!Generic named new function for
//!named functions
template<class CharT>
- void * priv_generic_named_construct(std::size_t type,
+ void * priv_generic_named_construct(unsigned char type,
const CharT *name,
- std::size_t num,
+ size_type num,
bool try2find,
bool dothrow,
detail::in_place_interface &table,
@@ -1205,8 +1209,8 @@
(void)is_intrusive;
std::size_t namelen = std::char_traits<CharT>::length(name);
- block_header_t block_info ( table.size*num
- , table.alignment
+ block_header_t block_info ( size_type(table.size*num)
+ , size_type(table.alignment)
, type
, sizeof(CharT)
, namelen);
@@ -1266,7 +1270,7 @@
//Allocate and construct the headers
if(is_node_index_t::value){
- std::size_t total_size = block_info.total_size_with_header<index_it>();
+ size_type total_size = block_info.template total_size_with_header<index_it>();
if(dothrow){
buffer_ptr = this->allocate(total_size);
}
@@ -1276,7 +1280,7 @@
return 0;
}
index_it *idr = new(buffer_ptr) index_it(it);
- hdr = block_header_t::from_first_header<index_it>(idr);
+ hdr = block_header_t::template from_first_header<index_it>(idr);
}
else{
if(dothrow){
Modified: trunk/boost/interprocess/shared_memory_object.hpp
==============================================================================
--- trunk/boost/interprocess/shared_memory_object.hpp (original)
+++ trunk/boost/interprocess/shared_memory_object.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -53,7 +53,7 @@
{
/// @cond
//Non-copyable and non-assignable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(shared_memory_object)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(shared_memory_object)
/// @endcond
public:
@@ -79,14 +79,14 @@
//!Moves the ownership of "moved"'s shared memory object to *this.
//!After the call, "moved" does not represent any shared memory object.
//!Does not throw
- shared_memory_object(BOOST_INTERPROCESS_RV_REF(shared_memory_object) moved)
+ shared_memory_object(BOOST_RV_REF(shared_memory_object) moved)
: m_handle(file_handle_t(detail::invalid_file()))
{ this->swap(moved); }
//!Moves the ownership of "moved"'s shared memory to *this.
//!After the call, "moved" does not represent any shared memory.
//!Does not throw
- shared_memory_object &operator=(BOOST_INTERPROCESS_RV_REF(shared_memory_object) moved)
+ shared_memory_object &operator=(BOOST_RV_REF(shared_memory_object) moved)
{
shared_memory_object tmp(boost::interprocess::move(moved));
this->swap(tmp);
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 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -108,7 +108,7 @@
typedef typename boost::pointer_to_other
<typename VoidAllocator::pointer, const VoidAllocator>::type const_allocator_pointer;
- BOOST_INTERPROCESS_COPYABLE_AND_MOVABLE(shared_ptr)
+ BOOST_COPYABLE_AND_MOVABLE(shared_ptr)
public:
//!Constructs an empty shared_ptr.
@@ -156,7 +156,7 @@
//!Move-Constructs a shared_ptr that takes ownership of other resource and
//!other is put in default-constructed state.
//!Throws: nothing.
- explicit shared_ptr(BOOST_INTERPROCESS_RV_REF(shared_ptr) other)
+ explicit shared_ptr(BOOST_RV_REF(shared_ptr) other)
: m_pn()
{ this->swap(other); }
@@ -195,7 +195,7 @@
//!Equivalent to shared_ptr(r).swap(*this).
//!Never throws
- shared_ptr & operator=(BOOST_INTERPROCESS_COPY_ASSIGN_REF(shared_ptr) r)
+ shared_ptr & operator=(BOOST_COPY_ASSIGN_REF(shared_ptr) r)
{
m_pn = r.m_pn; // shared_count::op= doesn't throw
return *this;
@@ -203,7 +203,7 @@
//!Move-assignment. Equivalent to shared_ptr(other).swap(*this).
//!Never throws
- shared_ptr & operator=(BOOST_INTERPROCESS_RV_REF(shared_ptr) other) // never throws
+ shared_ptr & operator=(BOOST_RV_REF(shared_ptr) other) // never throws
{
this_type(other).swap(*this);
return *this;
Modified: trunk/boost/interprocess/smart_ptr/unique_ptr.hpp
==============================================================================
--- trunk/boost/interprocess/smart_ptr/unique_ptr.hpp (original)
+++ trunk/boost/interprocess/smart_ptr/unique_ptr.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -151,7 +151,7 @@
//!deleter() and u.get_deleter() both reference the same lvalue deleter.
//!
//!Throws: nothing.
- unique_ptr(BOOST_INTERPROCESS_RV_REF(unique_ptr) u)
+ unique_ptr(BOOST_RV_REF(unique_ptr) u)
: ptr_(u.release(), boost::interprocess::forward<D>(u.get_deleter()))
{}
@@ -175,7 +175,7 @@
//!
//!Throws: nothing.
template <class U, class E>
- unique_ptr(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u,
+ unique_ptr(BOOST_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u,
typename detail::enable_if_c<
detail::is_convertible<typename unique_ptr<U, E>::pointer, pointer>::value &&
detail::is_convertible<E, D>::value &&
@@ -208,7 +208,7 @@
//!Returns: *this.
//!
//!Throws: nothing.
- unique_ptr& operator=(BOOST_INTERPROCESS_RV_REF(unique_ptr) u)
+ unique_ptr& operator=(BOOST_RV_REF(unique_ptr) u)
{
reset(u.release());
ptr_.second() = boost::interprocess::move(u.get_deleter());
@@ -230,7 +230,7 @@
//!
//!Throws: nothing.
template <class U, class E>
- unique_ptr& operator=(BOOST_INTERPROCESS_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u)
+ unique_ptr& operator=(BOOST_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u)
{
reset(u.release());
ptr_.second() = boost::interprocess::move(u.get_deleter());
@@ -325,7 +325,7 @@
/// @cond
private:
boost::compressed_pair<pointer, D> ptr_;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(unique_ptr)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_ptr)
template <class U, class E> unique_ptr(unique_ptr<U, E>&);
template <class U> unique_ptr(U&, typename detail::unique_ptr_error<U>::type = 0);
Modified: trunk/boost/interprocess/sync/file_lock.hpp
==============================================================================
--- trunk/boost/interprocess/sync/file_lock.hpp (original)
+++ trunk/boost/interprocess/sync/file_lock.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -39,7 +39,7 @@
{
/// @cond
//Non-copyable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(file_lock)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(file_lock)
/// @endcond
public:
@@ -56,14 +56,14 @@
//!Moves the ownership of "moved"'s file mapping object to *this.
//!After the call, "moved" does not represent any file mapping object.
//!Does not throw
- file_lock(BOOST_INTERPROCESS_RV_REF(file_lock) moved)
+ file_lock(BOOST_RV_REF(file_lock) moved)
: m_file_hnd(file_handle_t(detail::invalid_file()))
{ this->swap(moved); }
//!Moves the ownership of "moved"'s file mapping to *this.
//!After the call, "moved" does not represent any file mapping.
//!Does not throw
- file_lock &operator=(BOOST_INTERPROCESS_RV_REF(file_lock) moved)
+ file_lock &operator=(BOOST_RV_REF(file_lock) moved)
{
file_lock tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/sync/scoped_lock.hpp
==============================================================================
--- trunk/boost/interprocess/sync/scoped_lock.hpp (original)
+++ trunk/boost/interprocess/sync/scoped_lock.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -53,7 +53,7 @@
/// @cond
private:
typedef scoped_lock<Mutex> this_type;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(scoped_lock)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_lock)
typedef bool this_type::*unspecified_bool_type;
/// @endcond
public:
@@ -123,7 +123,7 @@
//! can be moved with the expression: "boost::interprocess::move(lock);". This
//! constructor does not alter the state of the mutex, only potentially
//! who owns it.
- scoped_lock(BOOST_INTERPROCESS_RV_REF(scoped_lock) scop)
+ scoped_lock(BOOST_RV_REF(scoped_lock) scop)
: mp_mutex(0), m_locked(scop.owns())
{ mp_mutex = scop.release(); }
@@ -140,7 +140,7 @@
//! other threads hold a sharable_lock on this mutex (sharable_lock's can
//! share ownership with an upgradable_lock).
template<class T>
- explicit scoped_lock(BOOST_INTERPROCESS_RV_REF(upgradable_lock<T>) upgr
+ explicit scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr
, typename detail::enable_if< detail::is_same<T, Mutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -168,7 +168,7 @@
//! If the "read lock" is held, then mutex transfer occurs only if it can
//! do so in a non-blocking manner.
template<class T>
- scoped_lock(BOOST_INTERPROCESS_RV_REF(upgradable_lock<T>) upgr, try_to_lock_type
+ scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr, try_to_lock_type
, typename detail::enable_if< detail::is_same<T, Mutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -198,7 +198,7 @@
//! merely changes type to an unlocked "write lock". If the "read lock" is held,
//! then mutex transfer occurs only if it can do so in a non-blocking manner.
template<class T>
- scoped_lock(BOOST_INTERPROCESS_RV_REF(upgradable_lock<T>) upgr, boost::posix_time::ptime &abs_time
+ scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr, boost::posix_time::ptime &abs_time
, typename detail::enable_if< detail::is_same<T, Mutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -229,7 +229,7 @@
//! If the "read lock" is held, then mutex transfer occurs only if it can
//! do so in a non-blocking manner.
template<class T>
- scoped_lock(BOOST_INTERPROCESS_RV_REF(sharable_lock<T>) shar, try_to_lock_type
+ scoped_lock(BOOST_RV_REF(sharable_lock<T>) shar, try_to_lock_type
, typename detail::enable_if< detail::is_same<T, Mutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -258,7 +258,7 @@
//! the same mutex before the assignment. In this case, this will own the
//! mutex after the assignment (and scop will not), but the mutex's lock
//! count will be decremented by one.
- scoped_lock &operator=(BOOST_INTERPROCESS_RV_REF(scoped_lock) scop)
+ scoped_lock &operator=(BOOST_RV_REF(scoped_lock) scop)
{
if(this->owns())
this->unlock();
Modified: trunk/boost/interprocess/sync/sharable_lock.hpp
==============================================================================
--- trunk/boost/interprocess/sync/sharable_lock.hpp (original)
+++ trunk/boost/interprocess/sync/sharable_lock.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -56,7 +56,7 @@
typedef sharable_lock<SharableMutex> this_type;
explicit sharable_lock(scoped_lock<mutex_type>&);
typedef bool this_type::*unspecified_bool_type;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(sharable_lock)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(sharable_lock)
/// @endcond
public:
@@ -124,7 +124,7 @@
//! signature. An non-moved sharable_lock can be moved with the expression:
//! "boost::interprocess::move(lock);". This constructor does not alter the state of the mutex,
//! only potentially who owns it.
- sharable_lock(BOOST_INTERPROCESS_RV_REF(sharable_lock<mutex_type>) upgr)
+ sharable_lock(BOOST_RV_REF(sharable_lock<mutex_type>) upgr)
: mp_mutex(0), m_locked(upgr.owns())
{ mp_mutex = upgr.release(); }
@@ -138,7 +138,7 @@
//! signature. An non-moved upgradable_lock can be moved with the expression:
//! "boost::interprocess::move(lock);".*/
template<class T>
- sharable_lock(BOOST_INTERPROCESS_RV_REF(upgradable_lock<T>) upgr
+ sharable_lock(BOOST_RV_REF(upgradable_lock<T>) upgr
, typename detail::enable_if< detail::is_same<T, SharableMutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -161,7 +161,7 @@
//! signature. An non-moved scoped_lock can be moved with the expression:
//! "boost::interprocess::move(lock);".
template<class T>
- sharable_lock(BOOST_INTERPROCESS_RV_REF(scoped_lock<T>) scop
+ sharable_lock(BOOST_RV_REF(scoped_lock<T>) scop
, typename detail::enable_if< detail::is_same<T, SharableMutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -188,7 +188,7 @@
//!Notes: With a recursive mutex it is possible that both this and upgr own the mutex
//! before the assignment. In this case, this will own the mutex after the assignment
//! (and upgr will not), but the mutex's lock count will be decremented by one.
- sharable_lock &operator=(BOOST_INTERPROCESS_RV_REF(sharable_lock<mutex_type>) upgr)
+ sharable_lock &operator=(BOOST_RV_REF(sharable_lock<mutex_type>) upgr)
{
if(this->owns())
this->unlock();
Modified: trunk/boost/interprocess/sync/upgradable_lock.hpp
==============================================================================
--- trunk/boost/interprocess/sync/upgradable_lock.hpp (original)
+++ trunk/boost/interprocess/sync/upgradable_lock.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -57,7 +57,7 @@
typedef upgradable_lock<UpgradableMutex> this_type;
explicit upgradable_lock(scoped_lock<mutex_type>&);
typedef bool this_type::*unspecified_bool_type;
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(upgradable_lock)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(upgradable_lock)
/// @endcond
public:
@@ -119,7 +119,7 @@
//! signature. An non-moved upgradable_lock can be moved with the
//! expression: "boost::interprocess::move(lock);". This constructor does not alter the
//! state of the mutex, only potentially who owns it.
- upgradable_lock(BOOST_INTERPROCESS_RV_REF(upgradable_lock<mutex_type>) upgr)
+ upgradable_lock(BOOST_RV_REF(upgradable_lock<mutex_type>) upgr)
: mp_mutex(0), m_locked(upgr.owns())
{ mp_mutex = upgr.release(); }
@@ -133,7 +133,7 @@
//! signature. An non-moved sharable_lock can be moved with the
//! expression: "boost::interprocess::move(lock);".
template<class T>
- upgradable_lock(BOOST_INTERPROCESS_RV_REF(scoped_lock<T>) scop
+ upgradable_lock(BOOST_RV_REF(scoped_lock<T>) scop
, typename detail::enable_if< detail::is_same<T, UpgradableMutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -161,7 +161,7 @@
//! "upgradable lock". If the "read lock" is held, then mutex transfer
//! occurs only if it can do so in a non-blocking manner.
template<class T>
- upgradable_lock( BOOST_INTERPROCESS_RV_REF(sharable_lock<T>) shar, try_to_lock_type
+ upgradable_lock( BOOST_RV_REF(sharable_lock<T>) shar, try_to_lock_type
, typename detail::enable_if< detail::is_same<T, UpgradableMutex> >::type * = 0)
: mp_mutex(0), m_locked(false)
{
@@ -192,7 +192,7 @@
//! mutex before the assignment. In this case, this will own the mutex
//! after the assignment (and upgr will not), but the mutex's upgradable lock
//! count will be decremented by one.
- upgradable_lock &operator=(BOOST_INTERPROCESS_RV_REF(upgradable_lock) upgr)
+ upgradable_lock &operator=(BOOST_RV_REF(upgradable_lock) upgr)
{
if(this->owns())
this->unlock();
Modified: trunk/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp
==============================================================================
--- trunk/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp (original)
+++ trunk/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -1,3 +1,12 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2011. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
#define BOOST_INTERPROCESS_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
@@ -103,3 +112,5 @@
} //namespace xsi {
} //namespace interprocess {
} //namespace boost {
+
+#endif //BOOST_INTERPROCESS_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
Modified: trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztanaga 2009. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2009-2011. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
@@ -49,7 +49,7 @@
/// @endcond
public:
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(xsi_named_mutex)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_named_mutex)
//!Default constructor.
//!Represents an empty xsi_named_mutex.
@@ -65,13 +65,13 @@
//!Moves the ownership of "moved"'s named mutex to *this.
//!After the call, "moved" does not represent any named mutex
//!Does not throw
- xsi_named_mutex(BOOST_INTERPROCESS_RV_REF(xsi_named_mutex) moved)
+ xsi_named_mutex(BOOST_RV_REF(xsi_named_mutex) moved)
{ this->swap(moved); }
//!Moves the ownership of "moved"'s named mutex to *this.
//!After the call, "moved" does not represent any named mutex.
//!Does not throw
- xsi_named_mutex &operator=(BOOST_INTERPROCESS_RV_REF(xsi_named_mutex) moved)
+ xsi_named_mutex &operator=(BOOST_RV_REF(xsi_named_mutex) moved)
{
xsi_named_mutex tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/windows_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/windows_shared_memory.hpp (original)
+++ trunk/boost/interprocess/windows_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -52,7 +52,7 @@
{
/// @cond
//Non-copyable and non-assignable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(windows_shared_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(windows_shared_memory)
/// @endcond
public:
@@ -80,14 +80,14 @@
//!Moves the ownership of "moved"'s shared memory object to *this.
//!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)
+ windows_shared_memory(BOOST_RV_REF(windows_shared_memory) moved)
: m_handle(0)
{ this->swap(moved); }
//!Moves the ownership of "moved"'s shared memory to *this.
//!After the call, "moved" does not represent any shared memory.
//!Does not throw
- windows_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(windows_shared_memory) moved)
+ windows_shared_memory &operator=(BOOST_RV_REF(windows_shared_memory) moved)
{
windows_shared_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
Modified: trunk/boost/interprocess/xsi_shared_memory.hpp
==============================================================================
--- trunk/boost/interprocess/xsi_shared_memory.hpp (original)
+++ trunk/boost/interprocess/xsi_shared_memory.hpp 2011-03-17 12:32:35 EDT (Thu, 17 Mar 2011)
@@ -49,7 +49,7 @@
{
/// @cond
//Non-copyable and non-assignable
- BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory)
+ BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory)
/// @endcond
public:
@@ -81,14 +81,14 @@
//!Moves the ownership of "moved"'s shared memory object to *this.
//!After the call, "moved" does not represent any shared memory object.
//!Does not throw
- xsi_shared_memory(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory) moved)
+ xsi_shared_memory(BOOST_RV_REF(xsi_shared_memory) moved)
: m_shmid(-1)
{ this->swap(moved); }
//!Moves the ownership of "moved"'s shared memory to *this.
//!After the call, "moved" does not represent any shared memory.
//!Does not throw
- xsi_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory) moved)
+ xsi_shared_memory &operator=(BOOST_RV_REF(xsi_shared_memory) moved)
{
xsi_shared_memory tmp(boost::interprocess::move(moved));
this->swap(tmp);
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