Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Class template private_node_allocator

boost::interprocess::private_node_allocator

Synopsis

template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
class private_node_allocator {
public:
  // types
  typedef implementation_defined::segment_manager segment_manager;
  typedef segment_manager::void_pointer           void_pointer;   
  typedef implementation_defined::pointer         pointer;        
  typedef implementation_defined::const_pointer   const_pointer;  
  typedef T                                       value_type;     
  typedef unspecified                             reference;      
  typedef unspecified                             const_reference;
  typedef std::size_t                             size_type;      
  typedef std::ptrdiff_t                          difference_type;
  template<typename T2> 
  struct rebind {
    // types
    typedef private_node_allocator< T2, SegmentManager, NodesPerBlock > other;
  };

  // construct/copy/destruct
  private_node_allocator(segment_manager *);
  private_node_allocator(const private_node_allocator &);
  template<typename T2> 
    private_node_allocator(const private_node_allocator< T2, SegmentManager, NodesPerBlock > &);
  template<typename T2, typename SegmentManager2, std::size_t N2> 
    private_node_allocator& 
    operator=(const private_node_allocator< T2, SegmentManager2, N2 > &);
  private_node_allocator& operator=(const private_node_allocator &);
  ~private_node_allocator();

  // public member functions
  node_pool_t * get_node_pool() const;
  segment_manager * get_segment_manager() const;
  size_type max_size() const;
  pointer allocate(size_type, cvoid_pointer = 0) ;
  void deallocate(const pointer &, size_type) ;
  void deallocate_free_blocks() ;
  pointer address(reference) const;
  const_pointer address(const_reference) const;
  void construct(const pointer &, const_reference) ;
  void destroy(const pointer &) ;
  size_type size(const pointer &) const;
  std::pair< pointer, bool > 
  allocation_command(allocation_type, size_type, size_type, size_type &, 
                     const pointer & = 0) ;
  multiallocation_iterator allocate_many(size_type, std::size_t) ;
  multiallocation_iterator allocate_many(const size_type *, size_type) ;
  void deallocate_many(multiallocation_iterator) ;
  pointer allocate_one() ;
  multiallocation_iterator allocate_individual(std::size_t) ;
  void deallocate_one(const pointer &) ;
  void deallocate_individual(multiallocation_iterator) ;
};

Description

An STL node allocator that uses a segment manager as memory source. The internal pointer type will of the same type (raw, smart) as "typename SegmentManager::void_pointer" type. This allows placing the allocator in shared memory, memory mapped-files, etc... This allocator has its own node pool. NodesPerBlock is the number of nodes allocated at once when the allocator needs runs out of nodes

private_node_allocator public construct/copy/destruct

  1. private_node_allocator(segment_manager * segment_mngr);

    Constructor from a segment manager. If not present, constructs a node pool. Increments the reference count of the associated node pool. Can throw boost::interprocess::bad_alloc

  2. private_node_allocator(const private_node_allocator & other);

    Copy constructor from other private_node_allocator. Increments the reference count of the associated node pool. Never throws

  3. template<typename T2> 
      private_node_allocator(const private_node_allocator< T2, SegmentManager, NodesPerBlock > & other);

    Copy constructor from related private_node_allocator. If not present, constructs a node pool. Increments the reference count of the associated node pool. Can throw boost::interprocess::bad_alloc

  4. template<typename T2, typename SegmentManager2, std::size_t N2> 
      private_node_allocator& 
      operator=(const private_node_allocator< T2, SegmentManager2, N2 > &);

    Not assignable from related private_node_allocator

  5. private_node_allocator& operator=(const private_node_allocator &);

    Not assignable from other private_node_allocator

  6. ~private_node_allocator();

    Destructor, removes node_pool_t from memory if its reference count reaches to zero. Never throws

private_node_allocator public member functions

  1. node_pool_t * get_node_pool() const;

    Returns a pointer to the node pool. Never throws

  2. segment_manager * get_segment_manager() const;

    Returns the segment manager. Never throws

  3. size_type max_size() const;

    Returns the number of elements that could be allocated. Never throws

  4. pointer allocate(size_type count, cvoid_pointer hint = 0) ;

    Allocate memory for an array of count elements. Throws boost::interprocess::bad_alloc if there is no enough memory

  5. void deallocate(const pointer & ptr, size_type count) ;

    Deallocate allocated memory. Never throws

  6. void deallocate_free_blocks() ;

    Deallocates all free blocks of the pool

  7. pointer address(reference value) const;

    Returns address of mutable object. Never throws

  8. const_pointer address(const_reference value) const;

    Returns address of non mutable object. Never throws

  9. void construct(const pointer & ptr, const_reference v) ;

    Copy construct an object. Throws if T's copy constructor throws

  10. void destroy(const pointer & ptr) ;

    Destroys object. Throws if object's destructor throws

  11. size_type size(const pointer & p) const;

    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.

  12. std::pair< pointer, bool > 
    allocation_command(allocation_type command, size_type limit_size, 
                       size_type preferred_size, size_type & received_size, 
                       const pointer & reuse = 0) ;
  13. multiallocation_iterator 
    allocate_many(size_type elem_size, std::size_t num_elements) ;

    Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be deallocated with deallocate(...)

  14. multiallocation_iterator 
    allocate_many(const size_type * elem_sizes, size_type n_elements) ;

    Allocates n_elements elements, each one of size elem_sizes[i]in a contiguous block of memory. The elements must be deallocated

  15. void deallocate_many(multiallocation_iterator it) ;

    Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be deallocated with deallocate(...)

  16. pointer allocate_one() ;

    Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws boost::interprocess::bad_alloc if there is no enough memory

  17. multiallocation_iterator allocate_individual(std::size_t num_elements) ;

    Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is 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().

  18. void deallocate_one(const pointer & p) ;

    Deallocates memory previously allocated with allocate_one(). You should never use deallocate_one to deallocate memory allocated with other functions different from allocate_one(). Never throws

  19. void deallocate_individual(multiallocation_iterator it) ;

    Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is 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().


PrevUpHomeNext