EIC code displayed by LXR master/​include/​boost/​interprocess/​segment_manager.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-10-30 08:20:55

 //////////////////////////////////////////////////////////////////////////////
 //
 // (C) Copyright Ion Gaztanaga 2005-2012. 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_SEGMENT_MANAGER_HPP
 #define BOOST_INTERPROCESS_SEGMENT_MANAGER_HPP
 
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
 #endif
 #
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
 
 #include <boost/interprocess/detail/config_begin.hpp>
 #include <boost/interprocess/detail/workaround.hpp>
 
 #include <boost/interprocess/detail/type_traits.hpp>
 
 #include <boost/interprocess/detail/transform_iterator.hpp>
 
 #include <boost/interprocess/detail/mpl.hpp>
 #include <boost/interprocess/detail/nothrow.hpp>
 #include <boost/interprocess/detail/segment_manager_helper.hpp>
 #include <boost/interprocess/detail/named_proxy.hpp>
 #include <boost/interprocess/detail/utilities.hpp>
 #include <boost/interprocess/offset_ptr.hpp>
 #include <boost/interprocess/indexes/iset_index.hpp>
 #include <boost/interprocess/exceptions.hpp>
 #include <boost/interprocess/allocators/allocator.hpp>
 #include <boost/interprocess/smart_ptr/deleter.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
 // container/detail
 #include <boost/container/detail/minimal_char_traits_header.hpp>
 #include <boost/container/detail/placement_new.hpp>
 // std
 #include <cstddef>   //std::size_t
 #include <boost/intrusive/detail/minimal_pair_header.hpp>
 #include <boost/assert.hpp>
 #ifndef BOOST_NO_EXCEPTIONS
 #include <exception>
 #endif
 #include <typeinfo>
 
 //!\file
 //!Describes the object placed in a memory segment that provides
 //!named object allocation capabilities for single-segment and
 //!multi-segment allocations.
 
 namespace boost{
 namespace interprocess{
 
 //!This object is the public base class of segment manager.
 //!This class only depends on the memory allocation algorithm
 //!and implements all the allocation features not related
 //!to named or unique objects.
 //!
 //!Storing a reference to segment_manager forces
 //!the holder class to be dependent on index types and character types.
 //!When such dependence is not desirable and only anonymous and raw
 //!allocations are needed, segment_manager_base is the correct answer.
 template<class MemoryAlgorithm>
 class segment_manager_base
    :  private MemoryAlgorithm
 {
    public:
    typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type;
    typedef typename MemoryAlgorithm::void_pointer  void_pointer;
    typedef typename MemoryAlgorithm::mutex_family  mutex_family;
    static const std::size_t MemAlignment = MemoryAlgorithm::Alignment;
    typedef MemoryAlgorithm memory_algorithm;
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //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;
 
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    //!This constant indicates the payload size
    //!associated with each allocation of the memory algorithm
    static const size_type PayloadPerAllocation = MemoryAlgorithm::PayloadPerAllocation;
 
    //!Constructor of the segment_manager_base
    //!
    //!"size" is the size of the memory segment where
    //!the basic segment manager is being constructed.
    //!
    //!"reserved_bytes" is the number of bytes
    //!after the end of the memory algorithm object itself
    //!that the memory algorithm will exclude from
    //!dynamic allocation
    //!
    //!Can throw
    segment_manager_base(size_type sz, size_type reserved_bytes)
       :  MemoryAlgorithm(sz, reserved_bytes)
    {
       BOOST_ASSERT((sizeof(segment_manager_base<MemoryAlgorithm>) == sizeof(MemoryAlgorithm)));
    }
 
    //!Returns the size of the memory
    //!segment
    size_type get_size() const
    {  return MemoryAlgorithm::get_size();  }
 
    //!Returns the number of free bytes of the memory
    //!segment
    size_type get_free_memory() const
    {  return MemoryAlgorithm::get_free_memory();  }
 
    //!Obtains the minimum size needed by
    //!the segment manager
    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 (size_type nbytes, const std::nothrow_t &)
    {  return MemoryAlgorithm::allocate(nbytes);   }
 
    //!Returns a reference to the internal memory algorithm.
    //!This function is useful for custom memory algorithms that
    //!need additional configuration options after construction. Never throws.
    //!This function should be only used by advanced users.
    MemoryAlgorithm &get_memory_algorithm()
    {  return static_cast<MemoryAlgorithm&>(*this);   }
 
    //!Returns a const reference to the internal memory algorithm.
    //!This function is useful for custom memory algorithms that
    //!need additional configuration options after construction. Never throws.
    //!This function should be only used by advanced users.
    const MemoryAlgorithm &get_memory_algorithm() const
    {  return static_cast<const MemoryAlgorithm&>(*this);   }
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //Experimental. Dont' use.
    //!Allocates n_elements of elem_bytes bytes.
    //!Throws bad_alloc on failure. chain.size() is not increased on failure.
    void allocate_many(size_type elem_bytes, size_type n_elements, multiallocation_chain &chain)
    {
       size_type prev_size = chain.size();
       MemoryAlgorithm::allocate_many(elem_bytes, n_elements, chain);
       if(!elem_bytes || chain.size() == prev_size){
          throw bad_alloc();
       }
    }
 
    //!Allocates n_elements, each one of element_lengths[i]*sizeof_element bytes.
    //!Throws bad_alloc on failure. chain.size() is not increased on failure.
    void allocate_many(const size_type *element_lengths, size_type n_elements, size_type sizeof_element, multiallocation_chain &chain)
    {
       size_type prev_size = chain.size();
       MemoryAlgorithm::allocate_many(element_lengths, n_elements, sizeof_element, chain);
       if(!sizeof_element || chain.size() == prev_size){
          throw bad_alloc();
       }
    }
 
    //!Allocates n_elements of elem_bytes bytes.
    //!Non-throwing version. chain.size() is not increased on failure.
    void allocate_many(const std::nothrow_t &, size_type elem_bytes, size_type n_elements, multiallocation_chain &chain)
    {  MemoryAlgorithm::allocate_many(elem_bytes, n_elements, chain); }
 
    //!Allocates n_elements, each one of
    //!element_lengths[i]*sizeof_element bytes.
    //!Non-throwing version. chain.size() is not increased on failure.
    void allocate_many(const std::nothrow_t &, const size_type *elem_sizes, size_type n_elements, size_type sizeof_element, multiallocation_chain &chain)
    {  MemoryAlgorithm::allocate_many(elem_sizes, n_elements, sizeof_element, chain); }
 
    //!Deallocates all elements contained in chain.
    //!Never throws.
    void deallocate_many(multiallocation_chain &chain)
    {  MemoryAlgorithm::deallocate_many(chain); }
 
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    //!Allocates nbytes bytes. Throws boost::interprocess::bad_alloc
    //!on failure
    void * allocate(size_type nbytes)
    {
       void * ret = MemoryAlgorithm::allocate(nbytes);
       if(!ret)
          throw bad_alloc();
       return ret;
    }
 
    //!Allocates nbytes bytes. This function is only used in
    //!single-segment management. Never throws
    void * allocate_aligned (size_type nbytes, size_type alignment, const 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(size_type nbytes, size_type alignment)
    {
       void * ret = MemoryAlgorithm::allocate_aligned(nbytes, alignment);
       if(!ret)
          throw bad_alloc();
       return ret;
    }
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    template<class T>
    T *allocation_command  (boost::interprocess::allocation_type command, size_type limit_size,
                            size_type &prefer_in_recvd_out_size, T *&reuse)
    {
       T *ret = MemoryAlgorithm::allocation_command
          (command | boost::interprocess::nothrow_allocation, limit_size, prefer_in_recvd_out_size, reuse);
       if(!(command & boost::interprocess::nothrow_allocation) && !ret)
          throw bad_alloc();
       return ret;
    }
 
    void *raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_objects,
                            size_type &prefer_in_recvd_out_size, void *&reuse, size_type sizeof_object = 1)
    {
       void *ret = MemoryAlgorithm::raw_allocation_command
          ( command | boost::interprocess::nothrow_allocation, limit_objects,
            prefer_in_recvd_out_size, reuse, sizeof_object);
       if(!(command & boost::interprocess::nothrow_allocation) && !ret)
          throw bad_alloc();
       return ret;
    }
 
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    //!Deallocates the bytes allocated with allocate/allocate_many()
    //!pointed by addr
    void   deallocate          (void *addr)
    {  MemoryAlgorithm::deallocate(addr);   }
 
    //!Increases managed memory in extra_size bytes more. This only works
    //!with single-segment management.
    void grow(size_type extra_size)
    {
       //Growing managed segments that use raw pointers is UB, so disallow it.
       BOOST_INTERPROCESS_STATIC_ASSERT(!(ipcdetail::is_same<void*, void_pointer>::value));
       MemoryAlgorithm::grow(extra_size);
    }
 
    //!Decreases managed memory to the minimum. This only works
    //!with single-segment management.
    void shrink_to_fit()
    {  MemoryAlgorithm::shrink_to_fit();   }
 
    //!Returns the result of "all_memory_deallocated()" function
    //!of the used memory algorithm
    bool all_memory_deallocated()
    {   return MemoryAlgorithm::all_memory_deallocated(); }
 
    //!Returns the result of "check_sanity()" function
    //!of the used memory algorithm
    bool check_sanity()
    {   return MemoryAlgorithm::check_sanity(); }
 
    //!Writes to zero free memory (memory not yet allocated)
    //!of the memory algorithm
    void zero_free_memory()
    {   MemoryAlgorithm::zero_free_memory(); }
 
    //!Returns the size of the buffer previously allocated pointed by ptr
    size_type size(const void *ptr) const
    {   return MemoryAlgorithm::size(ptr); }
 };
 
 //!This object is placed in the beginning of memory segment and
 //!implements the allocation (named or anonymous) of portions
 //!of the segment. This object contains two indexes that
 //!maintain an association between a name and a portion of the segment.
 //!
 //!The first index contains the mappings for normal named objects using the
 //!char type specified in the template parameter.
 //!
 //!The second index contains the association for unique instances. The key will
 //!be the const char * returned from type_info.name() function for the unique
 //!type to be constructed.
 //!
 //!segment_manager<CharType, MemoryAlgorithm, IndexType> inherits publicly
 //!from segment_manager_base<MemoryAlgorithm> and inherits from it
 //!many public functions related to anonymous object and raw memory allocation.
 //!See segment_manager_base reference to know about those functions.
 template<class CharType
         ,class MemoryAlgorithm
         ,template<class IndexConfig> class IndexType>
 class segment_manager
    :  public segment_manager_base<MemoryAlgorithm>
 {
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    //Non-copyable
    segment_manager();
    segment_manager(const segment_manager &);
    segment_manager &operator=(const segment_manager &);
    typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_t;
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    public:
    typedef MemoryAlgorithm                                  memory_algorithm;
    typedef typename segment_manager_base_t::void_pointer    void_pointer;
    typedef typename segment_manager_base_t::size_type       size_type;
    typedef typename segment_manager_base_t::difference_type difference_type;
    typedef CharType                                         char_type;
 
    typedef segment_manager_base<MemoryAlgorithm>   segment_manager_base_type;
 
    static const size_type PayloadPerAllocation = segment_manager_base_t::PayloadPerAllocation;
    static const size_type MemAlignment         = segment_manager_base_t::MemAlignment;
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    typedef ipcdetail::block_header<size_type> block_header_t;
    typedef ipcdetail::index_config<CharType, MemoryAlgorithm>  index_config_named;
    typedef ipcdetail::index_config<char, MemoryAlgorithm>      index_config_unique;
    typedef IndexType<index_config_named>                    index_type;
    typedef ipcdetail::bool_<is_intrusive_index<index_type>::value >    is_intrusive_t;
    typedef ipcdetail::bool_<is_node_index<index_type>::value>          is_node_index_t;
 
    public:
    typedef IndexType<index_config_named>                    named_index_t;
    typedef IndexType<index_config_unique>                   unique_index_t;
    typedef ipcdetail::char_ptr_holder<CharType>                char_ptr_holder_t;
    typedef ipcdetail::segment_manager_iterator_transform
       <typename named_index_t::const_iterator
       ,is_intrusive_index<index_type>::value>   named_transform;
 
    typedef ipcdetail::segment_manager_iterator_transform
       <typename unique_index_t::const_iterator
       ,is_intrusive_index<index_type>::value>   unique_transform;
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    typedef typename segment_manager_base_t::mutex_family       mutex_family;
 
    typedef transform_iterator
       <typename named_index_t::const_iterator, named_transform> const_named_iterator;
    typedef transform_iterator
       <typename unique_index_t::const_iterator, unique_transform> const_unique_iterator;
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //!Constructor proxy object definition helper class
    template<class T>
    struct construct_proxy
    {
       typedef ipcdetail::named_proxy<segment_manager, T, false>   type;
    };
 
    //!Constructor proxy object definition helper class
    template<class T>
    struct construct_iter_proxy
    {
       typedef ipcdetail::named_proxy<segment_manager, T, true>   type;
    };
 
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    //!Constructor of the segment manager
    //!"size" is the size of the memory segment where
    //!the segment manager is being constructed.
    //!Can throw
    explicit segment_manager(size_type segment_size)
       :  segment_manager_base_t(segment_size, priv_get_reserved_bytes())
       ,  m_header(static_cast<segment_manager_base_t*>(get_this_pointer()))
    {
       (void) anonymous_instance;   (void) unique_instance;
       //Check EBO is applied, it's required
       const void * const this_addr = this;
       const void *const segm_addr  = static_cast<segment_manager_base_t*>(this);
       (void)this_addr;  (void)segm_addr;
       BOOST_ASSERT( this_addr == segm_addr);
       const std::size_t void_ptr_alignment = boost::move_detail::alignment_of<void_pointer>::value; (void)void_ptr_alignment;
       BOOST_ASSERT((0 == (std::size_t)this_addr % boost::move_detail::alignment_of<segment_manager>::value));
    }
 
    //!Tries to find a previous named/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*, size_type> find  (char_ptr_holder_t name)
    {  return this->priv_find_impl<T>(name, true);  }
 
    //!Tries to find a previous named/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!
    //!Use it only inside atomic_func() calls, where the internal mutex
    //!is guaranteed to be locked.
    template <class T>
    std::pair<T*, size_type> find_no_lock  (char_ptr_holder_t name)
    {  return this->priv_find_impl<T>(name, false);  }
 
    //!Returns throwing "construct" proxy
    //!object
    template <class T>
    typename construct_proxy<T>::type
       construct(char_ptr_holder_t name)
    {  return typename construct_proxy<T>::type (this, name, false, true);  }
 
    //!Returns throwing "search or construct" proxy
    //!object
    template <class T>
    typename construct_proxy<T>::type find_or_construct(char_ptr_holder_t name)
    {  return typename construct_proxy<T>::type (this, name, true, true);  }
 
    //!Returns no throwing "construct" proxy
    //!object
    template <class T>
    typename construct_proxy<T>::type
       construct(char_ptr_holder_t name, const std::nothrow_t &)
    {  return typename construct_proxy<T>::type (this, name, false, false);  }
 
    //!Returns no throwing "search or construct"
    //!proxy object
    template <class T>
    typename construct_proxy<T>::type
       find_or_construct(char_ptr_holder_t name, const std::nothrow_t &)
    {  return typename construct_proxy<T>::type (this, name, true, false);  }
 
    //!Returns throwing "construct from iterators" proxy object
    template <class T>
    typename construct_iter_proxy<T>::type
       construct_it(char_ptr_holder_t name)
    {  return typename construct_iter_proxy<T>::type (this, name, false, true);  }
 
    //!Returns throwing "search or construct from iterators"
    //!proxy object
    template <class T>
    typename construct_iter_proxy<T>::type
       find_or_construct_it(char_ptr_holder_t name)
    {  return typename construct_iter_proxy<T>::type (this, name, true, true);  }
 
    //!Returns no throwing "construct from iterators"
    //!proxy object
    template <class T>
    typename construct_iter_proxy<T>::type
       construct_it(char_ptr_holder_t name, const std::nothrow_t &)
    {  return typename construct_iter_proxy<T>::type (this, name, false, false);  }
 
    //!Returns no throwing "search or construct from iterators"
    //!proxy object
    template <class T>
    typename construct_iter_proxy<T>::type
       find_or_construct_it(char_ptr_holder_t name, const std::nothrow_t &)
    {  return typename construct_iter_proxy<T>::type (this, name, true, false);  }
 
    //!Calls object function blocking recursive interprocess_mutex and guarantees that
    //!no new named_alloc or destroy will be executed by any process while
    //!executing the object function call
    template <class Func>
    void atomic_func(Func &f)
    {  scoped_lock<rmutex> guard(m_header);  f();  }
 
    //!Tries to calls a functor guaranteeing that no new construction, search or
    //!destruction will be executed by any process while executing the object
    //!function call. If the atomic function can't be immediatelly executed
    //!because the internal mutex is already locked, returns false.
    //!If the functor throws, this function throws.
    template <class Func>
    bool try_atomic_func(Func &f)
    {
       scoped_lock<rmutex> guard(m_header, try_to_lock);
       if(guard){
          f();
          return true;
       }
       else{
          return false;
       }
    }
 
    //!Destroys a previously created named/unique instance.
    //!Returns false if the object was not present.
    template <class T>
    bool destroy(char_ptr_holder_t name)
    {
       BOOST_ASSERT(!name.is_anonymous());
 
       if(name.is_unique()){
          return this->priv_generic_named_destroy<T, char>(typeid(T).name(), m_header.m_unique_index);
       }
       else{
          return this->priv_generic_named_destroy<T, CharType>(name.get(), m_header.m_named_index);
       }
    }
 
    //!Destroys an anonymous, unique or named object
    //!using its address
    template <class T>
    void destroy_ptr(const T *p)
    {
       priv_destroy_ptr(p);
    }
 
    //!Returns the name of an object created with construct/find_or_construct
    //!functions. Does not throw
    template<class T>
    static const CharType *get_instance_name(const T *ptr)
    { return priv_get_instance_name(block_header_t::block_header_from_value(ptr));  }
 
    //!Returns the length of an object created with construct/find_or_construct
    //!functions. Does not throw.
    template<class T>
    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
    //!functions. Does not throw
    template<class T>
    static instance_type get_instance_type(const T *ptr)
    {  return priv_get_instance_type(block_header_t::block_header_from_value(ptr));  }
 
    //!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(size_type num)
    {
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       m_header.m_named_index.reserve(num);
    }
 
    //!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(size_type num)
    {
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       m_header.m_unique_index.reserve(num);
    }
 
    //!Calls shrink_to_fit in both named and unique object indexes
    //!to try to free unused memory from those indexes.
    void shrink_to_fit_indexes()
    {
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       m_header.m_named_index.shrink_to_fit();
       m_header.m_unique_index.shrink_to_fit();
    }
 
    //!Returns the number of named objects stored in
    //!the segment.
    size_type get_num_named_objects()
    {
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       return m_header.m_named_index.size();
    }
 
    //!Returns the number of unique objects stored in
    //!the segment.
    size_type get_num_unique_objects()
    {
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       return m_header.m_unique_index.size();
    }
 
    //!Obtains the minimum size needed by the
    //!segment manager
    static size_type get_min_size()
    {  return segment_manager_base_t::get_min_size(priv_get_reserved_bytes());  }
 
    //!Returns a constant iterator to the beginning of the information about
    //!the named allocations performed in this segment manager
    const_named_iterator named_begin() const
    {
       return (make_transform_iterator)
          (m_header.m_named_index.begin(), named_transform());
    }
 
    //!Returns a constant iterator to the end of the information about
    //!the named allocations performed in this segment manager
    const_named_iterator named_end() const
    {
       return (make_transform_iterator)
          (m_header.m_named_index.end(), named_transform());
    }
 
    //!Returns a constant iterator to the beginning of the information about
    //!the unique allocations performed in this segment manager
    const_unique_iterator unique_begin() const
    {
       return (make_transform_iterator)
          (m_header.m_unique_index.begin(), unique_transform());
    }
 
    //!Returns a constant iterator to the end of the information about
    //!the unique allocations performed in this segment manager
    const_unique_iterator unique_end() const
    {
       return (make_transform_iterator)
          (m_header.m_unique_index.end(), unique_transform());
    }
 
    //!This is the default allocator to allocate types T
    //!from this managed segment
    template<class T>
    struct allocator
    {
       typedef boost::interprocess::allocator<T, segment_manager> type;
    };
 
    //!Returns an instance of the default allocator for type T
    //!initialized that allocates memory from this segment manager.
    template<class T>
    typename allocator<T>::type
       get_allocator()
    {   return typename allocator<T>::type(this); }
 
    //!This is the default deleter to delete types T
    //!from this managed segment.
    template<class T>
    struct deleter
    {
       typedef boost::interprocess::deleter<T, segment_manager> type;
    };
 
    //!Returns an instance of the default deleter for type T
    //!that will delete an object constructed in this segment manager.
    template<class T>
    typename deleter<T>::type
       get_deleter()
    {   return typename deleter<T>::type(this); }
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
    //!Generic named/anonymous new function. Offers all the possibilities,
    //!such as throwing, search before creating, and the constructor is
    //!encapsulated in an object function.
    template<class Proxy>
    typename Proxy::object_type * generic_construct
       (Proxy& pr, const CharType *name, size_type num, bool try2find, bool dothrow)
    {
       typedef typename Proxy::object_type object_type;
 
       //Security overflow check
       if(num > ((size_type)-1)/sizeof(object_type)){
          return ipcdetail::null_or_bad_alloc<object_type>(dothrow);
       }
       if(name == 0){
          return this->priv_anonymous_construct(pr, num, dothrow);
       }
       else if(name == reinterpret_cast<const CharType*>(-1)){
          return this->priv_generic_named_construct
             (pr, unique_type, typeid(object_type).name(), num, try2find, dothrow, m_header.m_unique_index);
       }
       else{
          return this->priv_generic_named_construct
             (pr, named_type, name, num, try2find, dothrow, m_header.m_named_index);
       }
    }
 
    private:
    //!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.
    template <class T>
    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);
       size_type sz;
       void *ret;
 
       if(name == reinterpret_cast<const CharType*>(-1)){
          ret = priv_generic_find<T>(typeid(T).name(), m_header.m_unique_index, sz, lock);
       }
       else{
          ret = priv_generic_find<T>(name, m_header.m_named_index, sz, lock);
       }
       return std::pair<T*, size_type>(static_cast<T*>(ret), sz);
    }
 
    //!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*, size_type> priv_find_impl (const ipcdetail::unique_instance_t*, bool lock)
    {
       size_type size;
       void *ret = priv_generic_find<T>(typeid(T).name(), m_header.m_unique_index, size, lock);
       return std::pair<T*, size_type>(static_cast<T*>(ret), size);
    }
 
 
    template<class Proxy>
    typename Proxy::object_type * priv_anonymous_construct(Proxy pr, size_type num, bool dothrow)
    {
       typedef typename Proxy::object_type object_type;
       BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<object_type>::value;
       block_header_t block_info (  size_type(sizeof(object_type)*num)
                                  , size_type(t_alignment)
                                  , anonymous_type
                                  , 1
                                  , 0);
 
       //Check if there is enough memory
       const std::size_t total_size = block_info.template total_anonymous_size<t_alignment>();
       #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2)
       void *ptr_struct = this->allocate(total_size, nothrow<>::get());
       #else
       void* ptr_struct = this->allocate_aligned(total_size, t_alignment, nothrow<>::get());
       #endif
       if(!ptr_struct){
          return ipcdetail::null_or_bad_alloc<object_type>(dothrow);
       }
 
       //Build scoped ptr to avoid leaks with constructor exception
       ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem
          (ptr_struct, *static_cast<segment_manager_base_type*>(this));
 
       //Now construct the header
       const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>();
 
       block_header_t * const hdr = ::new((char*)ptr_struct + front_space, boost_container_new_t()) block_header_t(block_info);
       BOOST_ASSERT(is_ptr_aligned(hdr));
       void *ptr = 0; //avoid gcc warning
       ptr = hdr->value();
 
       //Now call constructors
       pr.construct_n(ptr, num);
 
       //All constructors successful, disable rollback
       mem.release();
       object_type* const pret = static_cast<object_type*>(ptr);
       BOOST_ASSERT(is_ptr_aligned(pret));
       return pret;
    }
 
    //!Calls the destructor and makes an anonymous deallocate
    template <class T>
    void priv_anonymous_destroy(const T *object)
    {
       BOOST_ASSERT(is_ptr_aligned(object));
       //Get control data from associated with this object
       block_header_t *ctrl_data = block_header_t::block_header_from_value(object);
 
       //-------------------------------
       //scoped_lock<rmutex> guard(m_header);
       //-------------------------------
 
       //This is not an anonymous object, the pointer is wrong!
       BOOST_ASSERT(ctrl_data->alloc_type() == anonymous_type);
 
       //Call destructors and free memory
       //Build scoped ptr to avoid leaks with destructor exception
       priv_destroy_n(object, ctrl_data->value_bytes()/sizeof(T));
 
       BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment =
          boost::move_detail::alignment_of<T>::value;
       const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>();
       this->deallocate((char*)ctrl_data - front_space);
    }
 
    template<class T>
    void priv_destroy_ptr(const T *ptr)
    {
       BOOST_ASSERT(is_ptr_aligned(ptr));
       block_header_t *ctrl_data = block_header_t::block_header_from_value(ptr);
       switch(ctrl_data->alloc_type()){
          case anonymous_type:
             this->priv_anonymous_destroy(ptr);
          break;
 
          case named_type:
             this->priv_generic_named_destroy<T, CharType>
                (ctrl_data, m_header.m_named_index, is_node_index_t());
          break;
 
          case unique_type:
             this->priv_generic_named_destroy<T, char>
                (ctrl_data, m_header.m_unique_index, is_node_index_t());
          break;
 
          default:
             //This type is unknown, bad pointer passed to this function!
             BOOST_ASSERT(0);
          break;
       }
    }
 
    template<class T>
    static void priv_destroy_n(T* memory, std::size_t num)
    {
       for (std::size_t destroyed = 0; destroyed < num; ++destroyed)
          (memory++)->~T();
    }
 
    //!Returns the name of an object created with construct/find_or_construct
    //!functions. Does not throw
    static const CharType *priv_get_instance_name(block_header_t *ctrl_data)
    {
       boost::interprocess::allocation_type type = ctrl_data->alloc_type();
       if(type == anonymous_type){
          BOOST_ASSERT(ctrl_data->name_length() == 0);
          return 0;
       }
 
       BOOST_ASSERT(ctrl_data->name_length() != 0);
       CharType *name = static_cast<CharType*>(ctrl_data->template name<CharType>());
 
       //Sanity checks
       BOOST_ASSERT(ctrl_data->name_length() == std::char_traits<CharType>::length(name));
       return name;
    }
 
    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);
       return ctrl_data->value_bytes()/sizeofvalue;
    }
 
    //!Returns is the the name of an object created with construct/find_or_construct
    //!functions. Does not throw
    static instance_type priv_get_instance_type(block_header_t *ctrl_data)
    {
       //Get header
       BOOST_ASSERT((instance_type)ctrl_data->alloc_type() < max_allocation_type);
       return (instance_type)ctrl_data->alloc_type();
    }
 
    static size_type priv_get_reserved_bytes()
    {
       //Get the number of bytes until the end of (*this)
       //beginning in the end of the segment_manager_base_t base.
       return sizeof(segment_manager) - sizeof(segment_manager_base_t);
    }
 
    template <class T, class CharT>
    T *priv_generic_find
       (const CharT* name,
        IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
        size_type &length, bool use_lock)
    {
       typedef IndexType<ipcdetail::index_config
                            <CharT, MemoryAlgorithm> > index_t;
       typedef typename index_t::iterator              index_it;
       typedef typename index_t::compare_key_type      compare_key_t;
 
       //-------------------------------
       scoped_lock<rmutex> guard(priv_get_lock(use_lock));
       //-------------------------------
       //Find name in index
       compare_key_t key (name, std::char_traits<CharT>::length(name));
       index_it it = index.find(key);
 
       //Initialize return values
       void *ret_ptr  = 0;
       length         = 0;
 
       //If found, assign values
       if(it != index.end()){
          //Get header
          block_header_t *ctrl_data = priv_block_header_from_it(it, is_intrusive_t());
 
          //Sanity check
          BOOST_ASSERT((ctrl_data->value_bytes() % sizeof(T)) == 0);
          ret_ptr  = ctrl_data->value();
          length  = ctrl_data->value_bytes()/ sizeof(T);
       }
       return static_cast<T*>(ret_ptr);
    }
 
    template <class T, class CharT>
    bool priv_generic_named_destroy
      (block_header_t *block_header
      ,IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index
      ,ipcdetail::true_ is_node_index)
    {
       (void)is_node_index;
       typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >  index_t;
       typedef typename index_t::index_data_t         index_data_t;
 
       index_data_t* si = block_header_t::template to_first_header<index_data_t>(block_header);
       return this->priv_generic_named_destroy_impl<T, CharT>(*si, index);
    }
 
    template <class T, class CharT>
    bool priv_generic_named_destroy
      (block_header_t *block_header
      ,IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index
      ,ipcdetail::false_ is_node_index)
    {
       (void)is_node_index;
       CharT *name = static_cast<CharT*>(block_header->template name<CharT>());
       return this->priv_generic_named_destroy<T, CharT>(name, index);
    }
 
    template <class T, class CharT>
    bool priv_generic_named_destroy(const CharT *name,
                                    IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index)
    {
       typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >  index_t;
       typedef typename index_t::iterator              index_it;
       typedef typename index_t::compare_key_type      compare_key_t;
 
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       //Find name in index
       compare_key_t key(name, std::char_traits<CharT>::length(name));
       index_it it = index.find(key);
 
       //If not found, return false
       if(it == index.end()){
          //This name is not present in the index, wrong pointer or name!
          //BOOST_ASSERT(0);
          return false;
       }
       return this->priv_generic_named_destroy_impl<T, CharT>(it, index);
    }
 
    template <class T, class CharT>
    bool priv_generic_named_destroy_impl
       (typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator it,
       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index)
    {
       typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >  index_t;
       typedef typename index_t::index_data_t         index_data_t;
 
       //Get allocation parameters
       BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment =
          boost::move_detail::alignment_of<T>::value;
       block_header_t *ctrl_data = priv_block_header_from_it(it, is_intrusive_t());
 
       //Sanity checks
       BOOST_ASSERT((ctrl_data->value_bytes() % sizeof(T)) == 0);
 
       //Erase node from index
       index.erase(it);
 
       void *memory;
       BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value){
          index_data_t*ihdr = block_header_t::template to_first_header<index_data_t>(ctrl_data);
          const std::size_t front_space = block_header_t::template front_space_with_header<t_alignment, index_data_t>();
          memory = (char*)ihdr - front_space;
          ihdr->~index_data_t();
       }
       else{
          const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>();
          memory = (char*)ctrl_data - front_space;
       }
 
       //Call destructors and free memory
       priv_destroy_n(static_cast<T*>(ctrl_data->value()), ctrl_data->value_bytes()/sizeof(T));
 
       //Destroy the headers
       ctrl_data->~block_header_t();
 
       this->deallocate(memory);
       return true;
    }
 
    template<class IndexIt>
    static block_header_t* priv_block_header_from_it(IndexIt it, ipcdetail::true_) //is_intrusive
    {  return block_header_t::from_first_header(&*it); }
 
    template<class IndexIt>
    static block_header_t* priv_block_header_from_it(IndexIt it, ipcdetail::false_ ) //!is_intrusive
    {
       return static_cast<block_header_t*>(ipcdetail::to_raw_pointer(it->second.m_ptr));
    }
 
    //!Generic named new function for
    //!named functions
    template<class Proxy, class CharT>
    typename Proxy::object_type * priv_generic_named_construct
       (Proxy pr, unsigned char type, const CharT *name, size_type num, bool try2find, bool dothrow,
       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index)
    {
       typedef typename Proxy::object_type object_type;
       std::size_t namelen  = std::char_traits<CharT>::length(name);
       BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<object_type>::value;
 
       block_header_t block_info ( size_type(sizeof(object_type)*num)
                                 , size_type(t_alignment)
                                 , type
                                 , sizeof(CharT)
                                 , namelen);
 
       typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >  index_t;
       typedef typename index_t::iterator                       index_it;
       typedef typename index_t::compare_key_type               compare_key_t;
       typedef typename index_t::insert_commit_data   commit_data_t;
       typedef typename index_t::index_data_t  index_data_t;
 
       //-------------------------------
       scoped_lock<rmutex> guard(m_header);
       //-------------------------------
       //First, we want to know if the key is already present before
       //we allocate any memory, and if the key is not present, we
       //want to allocate all memory in a single buffer that will
       //contain the name and the user buffer.
       index_it existing_it;
       bool found = false;
 
       commit_data_t       commit_data;
       BOOST_INTERPROCESS_TRY{
          typedef std::pair<index_it, bool>                  index_ib;
          index_ib insert_ret = index.insert_check(compare_key_t(name, namelen), commit_data);
          existing_it = insert_ret.first;
          found = !insert_ret.second;
       }
       //Ignore exceptions
       BOOST_INTERPROCESS_CATCH(...){
          if(dothrow)
             BOOST_INTERPROCESS_RETHROW
          return 0;
       }
       BOOST_INTERPROCESS_CATCH_END
 
       //If found and this is find or construct, return data, error otherwise
       if(found){
          if(try2find){
             return static_cast<object_type*>(priv_block_header_from_it(existing_it, is_intrusive_t())->value());
          }
          return ipcdetail::null_or_already_exists<object_type>(dothrow);
       }
 
       //Allocates buffer for name + data, this can throw (it hurts)
       void *buffer_ptr;
       block_header_t * hdr;
       std::size_t front_space;
 
       //Allocate and construct the headers
       BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value){
          const size_type total_size = block_info.template total_named_size_with_header<t_alignment, CharT, index_data_t>(namelen);
          #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2)
          buffer_ptr = this->allocate(total_size, nothrow<>::get());
          #else
          buffer_ptr = this->allocate_aligned(total_size, t_alignment, nothrow<>::get());
          #endif
          
          if(!buffer_ptr)
             return ipcdetail::null_or_bad_alloc<object_type>(dothrow);
 
          front_space = block_header_t::template front_space_with_header<t_alignment, index_data_t>();
          hdr = block_header_t::template from_first_header(reinterpret_cast<index_data_t*>((void*)((char*)buffer_ptr + front_space)));
       }
       else{
          const size_type total_size = block_info.template total_named_size<t_alignment, CharT>(namelen);
          #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2)
          buffer_ptr = this->allocate(total_size, nothrow<>::get());
          #else
          buffer_ptr = this->allocate_aligned(total_size, t_alignment, nothrow<>::get());
          #endif
 
          front_space = block_header_t::template front_space_without_header<t_alignment>();
          
          //Check if there is enough memory
          if (!buffer_ptr)
             return ipcdetail::null_or_bad_alloc<object_type>(dothrow);
          hdr = reinterpret_cast<block_header_t*>((void*)((char*)buffer_ptr + front_space));
       }
 
       BOOST_ASSERT(is_ptr_aligned(hdr));
       hdr = ::new(hdr, boost_container_new_t()) block_header_t(block_info);
 
       //Build scoped ptr to avoid leaks with constructor exception
       ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem
          (buffer_ptr, *static_cast<segment_manager_base_type*>(this));
 
       void *ptr = hdr->value();
 
       //Copy name to memory segment and insert data
       hdr->store_name_length(static_cast<typename block_header_t::name_len_t>(namelen));
       CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>());
       std::char_traits<CharT>::copy(name_ptr, name, namelen+1);
 
       index_it it;
       BOOST_INTERPROCESS_TRY{
          BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value) {
             index_data_t* index_data = ::new((char*)buffer_ptr + front_space, boost_container_new_t()) index_data_t();
             BOOST_ASSERT(is_ptr_aligned(index_data));
             it = index.insert_commit(compare_key_t(name_ptr, namelen), hdr, *index_data, commit_data);
          }
          else{
             index_data_t id;
             it = index.insert_commit(compare_key_t(name_ptr, namelen), hdr, id, commit_data);
          }
       }
       //Ignore exceptions
       BOOST_INTERPROCESS_CATCH(...){
          if(dothrow)
             BOOST_INTERPROCESS_RETHROW
          return 0;
       }
       BOOST_INTERPROCESS_CATCH_END
 
       //Initialize the node value_eraser to erase inserted node
       //if something goes wrong
       value_eraser<index_t> v_eraser(index, it);
 
       //Construct array, this can throw
       pr.construct_n(ptr, num);
 
       //Release rollbacks since construction was successful
       v_eraser.release();
       mem.release();
       object_type* const pret = static_cast<object_type*>(ptr);
       BOOST_ASSERT(is_ptr_aligned(pret));
       return pret;
    }
 
    private:
    //!Returns the this pointer
    segment_manager *get_this_pointer()
    {  return this;  }
 
    typedef typename MemoryAlgorithm::mutex_family::recursive_mutex_type   rmutex;
 
    scoped_lock<rmutex> priv_get_lock(bool use_lock)
    {
       scoped_lock<rmutex> local(m_header, defer_lock);
       if(use_lock){
          local.lock();
       }
       return scoped_lock<rmutex>(boost::move(local));
    }
 
    //!This struct includes needed data and derives from
    //!rmutex to allow EBO when using null interprocess_mutex
    struct header_t
       :  public rmutex
    {
       named_index_t           m_named_index;
       unique_index_t          m_unique_index;
 
       header_t(segment_manager_base_t *segment_mngr_base)
          :  m_named_index (segment_mngr_base)
          ,  m_unique_index(segment_mngr_base)
       {}
    }  m_header;
 
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
 
 }} //namespace boost { namespace interprocess
 
 #include <boost/interprocess/detail/config_end.hpp>
 
 #endif //#ifndef BOOST_INTERPROCESS_SEGMENT_MANAGER_HPP
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team