Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template cached_node_allocator

boost::interprocess::cached_node_allocator

Synopsis

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

template<typename T, typename SegmentManager,  NodesPerBlock> 
class cached_node_allocator {
public:
  // types
  typedef  ;
  typedef            ;   
  typedef          ;        
  typedef    ;  
  typedef                                        ;     
  typedef                              ;      
  typedef                              ;
  typedef                ;      
  typedef          ;

  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef cached_node_allocator<  ;
  };

  // construct/copy/destruct
  ();
  (cached_node_allocator &);
  template<typename T2> 
    (cached_node_allocator< );
  template<typename T2, typename SegmentManager2,  N2> 
    cached_node_allocator & 
    (cached_node_allocator< );
  cached_node_allocator & (cached_node_allocator &);
  ~();

  // public member functions
   () ;
   () ;
   () ;
   (,  = );
   (, );
   ();
   () ;
   () ;
   (, );
   ();
   () ;
   (, , 
                             , );
   (, , );
   (, , );
   ();
   ();
   ();
   ();
   ();
   ();
   () ;

  // friend functions
   (, );
};

Description

cached_node_allocator public construct/copy/destruct

  1. ( 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. (cached_node_allocator & other);

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

  3. template<typename T2> 
      (cached_node_allocator<  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

  4. template<typename T2, typename SegmentManager2,  N2> 
      cached_node_allocator & 
      (cached_node_allocator< );

    Not assignable from related cached_node_allocator

  5. cached_node_allocator & (cached_node_allocator &);

    Not assignable from other cached_node_allocator

  6. ~();

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

cached_node_allocator public member functions

  1.  () ;

    Returns a pointer to the node pool. Never throws

  2.  () ;

    Returns the segment manager. Never throws

  3.  () ;

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

  4.  ( count,  hint = );

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

  5.  ( ptr,  count);

    Deallocate allocated memory. Never throws

  6.  ();

    Deallocates all free blocks of the pool

  7.  ( value) ;

    Returns address of mutable object. Never throws

  8.  ( value) ;

    Returns address of non mutable object. Never throws

  9.  ( ptr,  v);

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

  10.  ( ptr);

    Destroys object. Throws if object's destructor throws

  11.  ( p) ;

    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.  ( command, 
                                limit_size, 
                                prefer_in_recvd_out_size, 
                                reuse);
  13.  ( elem_size,  num_elements, 
                        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(...)

  14.  ( elem_sizes,  n_elements, 
                        chain);

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

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

  16.  ();

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

  20.  ( newmax);

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

  21.  () ;

    Returns the max cached nodes parameter. Never throws

cached_node_allocator friend functions

  1.  ( alloc1,  alloc2);

    Swaps allocators. Does not throw. If each allocator is placed in a different memory segment, the result is undefined.


PrevUpHomeNext