Class template private_node

Class template private_node_allocator

boost::interprocess::private_node_allocator

Synopsis

// In header: <boost/interprocess/allocators/private_node_allocator.hpp>

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 segment_manager::size_type              size_type;      
  typedef segment_manage::difference_type         difference_type;

  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef private_node_allocator< T2, SegmentManager, NodesPerBlock > other;
  };

  // private member functions
  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 &);

  // public member functions
  private_node_allocator(segment_manager *);
  private_node_allocator(const private_node_allocator &);
  private_node_allocator(private_node_allocator &&);
  template<typename T2> 
    private_node_allocator(const private_node_allocator< T2, SegmentManager, NodesPerBlock > &);
  ~private_node_allocator();
  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;
  template<typename U, class ... Args> void construct(U *, Args &&...);
  size_type size(const pointer &) const;
  void allocate_many(size_type, size_type, multiallocation_chain &);
  void allocate_many(const size_type *, size_type, multiallocation_chain &);
  void deallocate_many(multiallocation_chain &);
  pointer allocate_one();
  void allocate_individual(size_type, multiallocation_chain &);
  void deallocate_one(const pointer &);
  void deallocate_individual(multiallocation_chain &);

  // friend functions
  void swap(self_t &, self_t &);
};

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` private member functions

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

private_node_allocator & operator=(const private_node_allocator &);

Not assignable from other private_node_allocator

`private_node_allocator` public member functions

```
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
```
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
```
private_node_allocator(private_node_allocator && other);
```
Move constructor from other. Increments the reference count of the associated node pool and captures the cache. Never throws
```
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
```
~private_node_allocator();
```
Destructor, removes node_pool_t from memory if its reference count reaches to zero. Never throws
```
node_pool_t * get_node_pool() const;
```
Returns a pointer to the node pool. Never throws

segment_manager * get_segment_manager() const;

Returns the segment manager. Never throws

```
size_type max_size() const;
```
Returns the number of elements that could be allocated. Never throws
```
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

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

Deallocate allocated memory. Never throws

```
void deallocate_free_blocks();
```
Deallocates all free blocks of the pool
```
pointer address(reference value) const;
```
Returns address of mutable object. Never throws This function is deprecated and will be removed in the future
```
const_pointer address(const_reference value) const;
```
Returns address of non mutable object. Never throws This function is deprecated and will be removed in the future
```
template<typename U, class ... Args> void construct(U * p, Args &&... args);
```
Requires: Uses-allocator construction of T with allocator argument uses_segment_manager_t and additional 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]

Effects: Construct a T object at p by uses-allocator construction with allocator argument constructible from segment_manager* and constructor arguments std::forward<Args>(args)....

Throws: Nothing unless the constructor for T throws.
```
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. This function is deprecated and will be removed in the future
```
void allocate_many(size_type elem_size, size_type num_elements, 
                   multiallocation_chain & chain);
```
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(...) This function is deprecated and will be removed in the future
```
void allocate_many(const size_type * elem_sizes, size_type n_elements, 
                   multiallocation_chain & chain);
```
Allocates n_elements elements, each one of size elem_sizes[i]in a contiguous block of memory. The elements must be deallocated This function is deprecated and will be removed in the future
```
void deallocate_many(multiallocation_chain & chain);
```
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(...) This function is deprecated and will be removed in the future
```
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
```
void allocate_individual(size_type num_elements, 
                         multiallocation_chain & chain);
```
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().
```
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
```
void deallocate_individual(multiallocation_chain & chain);
```
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().

`private_node_allocator` friend functions

```
void swap(self_t & alloc1, self_t & alloc2);
```
Swaps allocators. Does not throw. If each allocator is placed in a different memory segment, the result is undefined.