cached_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

cached_node_allocator(const cached_node_allocator & other);

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

template<typename T2> 
  cached_node_allocator(const cached_node_allocator< T2, SegmentManager, NodesPerBlock > & other);

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

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

Not assignable from related cached_node_allocator

cached_node_allocator& operator=(const cached_node_allocator &);

Not assignable from other cached_node_allocator

~cached_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

const_pointer address(const_reference value) const;

Returns address of non mutable object. Never throws

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

Default construct an object. Throws if T's default constructor throws

void destroy(const pointer & ptr);

Destroys object. Throws if object's destructor 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.

std::pair< pointer, bool > 
allocation_command(boost::interprocess::allocation_type command, 
                   size_type limit_size, size_type preferred_size, 
                   size_type & received_size, const pointer & reuse = 0);

multiallocation_chain 
allocate_many(size_type elem_size, size_type 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(...)

multiallocation_chain 
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

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(...)

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

multiallocation_chain allocate_individual(size_type 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().

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 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().

void set_max_cached_nodes(size_type newmax);

Sets the new max cached nodes value. This can provoke deallocations if "newmax" is less than current cached nodes. Never throws

size_type get_max_cached_nodes() const;

Returns the max cached nodes parameter. Never throws

friend 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.