Implement "uses allocator" for all allocator.

Author: igaztanaga

include/boost/interprocess/allocators/adaptive_pool.hpp

@@ -22,19 +22,24 @@
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
 
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/assert.hpp>
 
+#include <boost/intrusive/pointer_traits.hpp>
 #include <boost/interprocess/interprocess_fwd.hpp>
-#include <boost/assert.hpp>
-#include <boost/container/detail/addressof.hpp>
+
+#include <boost/interprocess/containers/version_type.hpp>
+#include <boost/interprocess/exceptions.hpp>
+
 #include <boost/interprocess/detail/utilities.hpp>
 #include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
 #include <boost/interprocess/allocators/detail/adaptive_node_pool.hpp>
-#include <boost/interprocess/containers/version_type.hpp>
-#include <boost/interprocess/exceptions.hpp>
 #include <boost/interprocess/allocators/detail/allocator_common.hpp>
+
 #include <boost/container/detail/multiallocation_chain.hpp>
-#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+#include <boost/container/detail/addressof.hpp>
+
 #include <boost/move/adl_move_swap.hpp>
 #include <cstddef>
 
@@ -168,6 +173,24 @@ class adaptive_pool_base
    segment_manager* get_segment_manager()const
    {  return node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->get_segment_manager();  }
 
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template < typename U, class ...Args>
+   inline void construct(U* p, BOOST_FWD_REF(Args)...args)
+   {
+      boost::container::dtl::allocator_traits_dummy<U> atd;
+      boost::container::dtl::dispatch_uses_allocator
+         (atd, this->get_segment_manager(), p, ::boost::forward<Args>(args)...);
+   }
+
    //!Swaps allocators. Does not throw. If each allocator is placed in a
    //!different memory segment, the result is undefined.
    friend void swap(self_t &alloc1, self_t &alloc2)
@@ -378,15 +401,20 @@ class adaptive_pool
    //!Returns address of non mutable object.
    //!Never throws
    const_pointer address(const_reference value) const;
-/*
-   //!Copy construct an object.
-   //!Throws if T's copy constructor throws
-   void construct(const pointer &ptr, const_reference v);
-
-   //!Destroys object. Throws if object's
-   //!destructor throws
-   void destroy(const pointer &ptr);
-*/
+
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template <typename U, class ...Args>
+   void construct(U* p, BOOST_FWD_REF(Args)...args);
+
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold. This size only works for memory allocated with
    //!allocate, allocation_command and allocate_many.

include/boost/interprocess/allocators/allocator.hpp

@@ -32,9 +32,11 @@
 #include <boost/interprocess/containers/version_type.hpp>
 #include <boost/interprocess/exceptions.hpp>
 #include <boost/assert.hpp>
-#include <boost/container/detail/addressof.hpp>
 #include <boost/interprocess/detail/type_traits.hpp>
+
 #include <boost/container/detail/placement_new.hpp>
+#include <boost/container/detail/addressof.hpp>
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
 
 #include <cstddef>
 #include <stdexcept>
@@ -158,6 +160,24 @@ class allocator
    void deallocate(const pointer &ptr, size_type)
    {  mp_mngr->deallocate((void*)ipcdetail::to_raw_pointer(ptr));  }
 
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template < typename U, class ...Args>
+   inline void construct(U* p, BOOST_FWD_REF(Args)...args)
+   {
+      boost::container::dtl::allocator_traits_dummy<U> atd;
+      boost::container::dtl::dispatch_uses_allocator
+         (atd, this->get_segment_manager(), p, ::boost::forward<Args>(args)...);
+   }
+
    //!Returns the number of elements that could be allocated.
    //!Never throws
    size_type max_size() const

include/boost/interprocess/allocators/cached_adaptive_pool.hpp

@@ -281,13 +281,18 @@ class cached_adaptive_pool
    //!Never throws
    const_pointer address(const_reference value) const;
 
-   //!Copy construct an object.
-   //!Throws if T's copy constructor throws
-   void construct(const pointer &ptr, const_reference v);
-
-   //!Destroys object. Throws if object's
-   //!destructor throws
-   void destroy(const pointer &ptr);
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template <typename U, class ...Args>
+   void construct(U* p, BOOST_FWD_REF(Args)...args);
 
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold. This size only works for memory allocated with

include/boost/interprocess/allocators/cached_node_allocator.hpp

@@ -23,12 +23,15 @@
 #include <boost/interprocess/detail/workaround.hpp>
 
 #include <boost/interprocess/interprocess_fwd.hpp>
+
 #include <boost/interprocess/allocators/detail/node_pool.hpp>
 #include <boost/interprocess/allocators/detail/allocator_common.hpp>
-#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/allocators/detail/node_tools.hpp>
 #include <boost/interprocess/detail/utilities.hpp>
 #include <boost/interprocess/containers/version_type.hpp>
-#include <boost/interprocess/allocators/detail/node_tools.hpp>
+
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+
 #include <cstddef>
 
 //!\file
@@ -250,13 +253,18 @@ class cached_node_allocator
    //!Never throws
    pointer address(reference value) const;
 
-   //!Returns address of non mutable object.
-   //!Never throws
-   const_pointer address(const_reference value) const;
-
-   //!Default construct an object.
-   //!Throws if T's default constructor throws
-   void construct(const pointer &ptr, const_reference v);
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template <typename U, class ...Args>
+   void construct(U* p, BOOST_FWD_REF(Args)...args);
 
    //!Destroys object. Throws if object's
    //!destructor throws

include/boost/interprocess/allocators/detail/allocator_common.hpp

@@ -22,22 +22,27 @@
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
 
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/assert.hpp>   //BOOST_ASSERT
 
 #include <boost/interprocess/interprocess_fwd.hpp>
-#include <boost/interprocess/detail/utilities.hpp> //to_raw_pointer
-#include <boost/container/detail/addressof.hpp> //boost::container::dtl:addressof
-#include <boost/assert.hpp>   //BOOST_ASSERT
+
 #include <boost/interprocess/exceptions.hpp> //bad_alloc
 #include <boost/interprocess/sync/scoped_lock.hpp> //scoped_lock
 #include <boost/interprocess/containers/allocation_type.hpp> //boost::interprocess::allocation_type
-#include <boost/container/detail/multiallocation_chain.hpp>
 #include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+
 #include <boost/interprocess/detail/segment_manager_helper.hpp>
-#include <boost/move/utility_core.hpp>
 #include <boost/interprocess/detail/type_traits.hpp>
-#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/utilities.hpp> //to_raw_pointer
+
+#include <boost/intrusive/pointer_traits.hpp>
+
 #include <boost/container/detail/placement_new.hpp>
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/container/detail/addressof.hpp> //boost::container::dtl:addressof
+
+#include <boost/move/utility_core.hpp>
 #include <boost/move/adl_move_swap.hpp>
 
 namespace boost {
@@ -615,6 +620,24 @@ class cached_allocator_impl
    segment_manager* get_segment_manager()const
    {  return m_cache.get_segment_manager();   }
 
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template < typename U, class ...Args>
+   inline void construct(U* p, BOOST_FWD_REF(Args)...args)
+   {
+      boost::container::dtl::allocator_traits_dummy<U> atd;
+      boost::container::dtl::dispatch_uses_allocator
+         (atd, this->get_segment_manager(), p, ::boost::forward<Args>(args)...);
+   }
+
    //!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(size_type newmax)

include/boost/interprocess/allocators/node_allocator.hpp

@@ -22,18 +22,23 @@
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
 
+#include <boost/assert.hpp>
+
 #include <boost/intrusive/pointer_traits.hpp>
 
 #include <boost/interprocess/interprocess_fwd.hpp>
-#include <boost/assert.hpp>
-#include <boost/container/detail/addressof.hpp>
-#include <boost/interprocess/detail/utilities.hpp>
-#include <boost/interprocess/detail/type_traits.hpp>
 #include <boost/interprocess/allocators/detail/node_pool.hpp>
 #include <boost/interprocess/containers/version_type.hpp>
-#include <boost/container/detail/multiallocation_chain.hpp>
 #include <boost/interprocess/exceptions.hpp>
 #include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+
+
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/container/detail/addressof.hpp>
+
 #include <boost/move/adl_move_swap.hpp>
 #include <cstddef>
 
@@ -167,6 +172,24 @@ class node_allocator_base
    segment_manager* get_segment_manager()const
    {  return node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->get_segment_manager();  }
 
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template < typename U, class ...Args>
+   inline void construct(U* p, BOOST_FWD_REF(Args)...args)
+   {
+      boost::container::dtl::allocator_traits_dummy<U> atd;
+      boost::container::dtl::dispatch_uses_allocator
+         (atd, this->get_segment_manager(), p, ::boost::forward<Args>(args)...);
+   }
+
    //!Swaps allocators. Does not throw. If each allocator is placed in a
    //!different memory segment, the result is undefined.
    friend void swap(self_t &alloc1, self_t &alloc2)
@@ -364,13 +387,18 @@ class node_allocator
    //!Never throws
    const_pointer address(const_reference value) const;
 
-   //!Copy construct an object.
-   //!Throws if T's copy constructor throws
-   void construct(const pointer &ptr, const_reference v);
-
-   //!Destroys object. Throws if object's
-   //!destructor throws
-   void destroy(const pointer &ptr);
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template <typename U, class ...Args>
+   void construct(U* p, BOOST_FWD_REF(Args)...args);
 
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold. This size only works for memory allocated with

include/boost/interprocess/allocators/private_adaptive_pool.hpp

@@ -32,7 +32,9 @@
 #include <boost/container/detail/multiallocation_chain.hpp>
 #include <boost/interprocess/exceptions.hpp>
 #include <boost/interprocess/detail/utilities.hpp>
-#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/container/detail/dispatch_uses_allocator.hpp>
+
 #include <boost/move/adl_move_swap.hpp>
 #include <cstddef>
 
@@ -175,6 +177,24 @@ class private_adaptive_pool_base
    segment_manager* get_segment_manager()const
    {  return m_node_pool.get_segment_manager(); }
 
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template < typename U, class ...Args>
+   inline void construct(U* p, BOOST_FWD_REF(Args)...args)
+   {
+      boost::container::dtl::allocator_traits_dummy<U> atd;
+      boost::container::dtl::dispatch_uses_allocator
+         (atd, this->get_segment_manager(), p, ::boost::forward<Args>(args)...);
+   }
+
    //!Returns the internal node pool. Never throws
    node_pool_t* get_node_pool() const
    {  return const_cast<node_pool_t*>(&m_node_pool); }
@@ -412,13 +432,18 @@ class private_adaptive_pool
    //!Never throws
    const_pointer address(const_reference value) const;
 
-   //!Copy construct an object.
-   //!Throws if T's copy constructor throws
-   void construct(const pointer &ptr, const_reference v);
-
-   //!Destroys object. Throws if object's
-   //!destructor throws
-   void destroy(const pointer &ptr);
+   //! <b>Requires</b>: Uses-allocator construction of T with allocator
+   //!   `segment_manager*` and constructor arguments `std::forward<Args>(args)...`
+   //!   is well-formed. [Note: uses-allocator construction is always well formed for
+   //!   types that do not use allocators. - end note]
+   //!
+   //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
+   //!   argument constructible from `segment_manager*`
+   //!  and constructor arguments `std::forward<Args>(args)...`.
+   //!
+   //! <b>Throws</b>: Nothing unless the constructor for T throws.
+   template <typename U, class ...Args>
+   void construct(U* p, BOOST_FWD_REF(Args)...args);
 
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold. This size only works for memory allocated with