| Home | Libraries | People | FAQ | More

## Class template cached_node_allocator<T, detail::shared_node_pool< SegmentManager, sizeof_value< T >::value, NodesPerBlock >, 2>

boost::interprocess::cached_node_allocator<T, detail::shared_node_pool< SegmentManager, sizeof_value< T >::value, NodesPerBlock >, 2>

## Synopsis

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

    template<typename T, typename SegmentManager, std::size_t NodesPerBlock>
    class cached_node_allocator<T, detail::shared_node_pool< SegmentManager, sizeof_value< T >::value, NodesPerBlock >, 2> {
    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;

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

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

      // public member functions
       cached_node_allocator(segment_manager *);
       cached_node_allocator(const cached_node_allocator &);
      template<typename T2>
         cached_node_allocator(const cached_node_allocator< T2, SegmentManager, NodesPerBlock > &);
       ~cached_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;
      void construct(const pointer &, const_reference);
      void destroy(const pointer &);
      size_type size(const pointer &) const;
      std::pair< pointer, bool >
      allocation_command(boost::interprocess::allocation_type, size_type,
                         size_type, size_type &, const pointer & = 0);
      multiallocation_chain allocate_many(size_type, std::size_t);
      multiallocation_chain allocate_many(const size_type *, size_type);
      void deallocate_many(multiallocation_chain);
      pointer allocate_one();
      multiallocation_chain allocate_individual(std::size_t);
      void deallocate_one(const pointer &);
      void deallocate_individual(multiallocation_chain);
      void set_max_cached_nodes(std::size_t);
      std::size_t get_max_cached_nodes() const;

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

## Description

@ : public detail::cached_allocator_impl

### `cached_node_allocator` public construct/copy/destruct

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

2.     cached_node_allocator& operator=(const cached_node_allocator &);

   Not assignable from other cached_node_allocator

### `cached_node_allocator` public member functions

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

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

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

4.      ~cached_node_allocator();

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

5.     node_pool_t * get_node_pool() const;

   Returns a pointer to the node pool. Never throws

6.     segment_manager * get_segment_manager() const;

   Returns the segment manager. Never throws

7.     size_type max_size() const;

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

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

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

   Deallocate allocated memory. Never throws

10.     void deallocate_free_blocks();

    Deallocates all free blocks of the pool

11.     pointer address(reference value) const;

    Returns address of mutable object. Never throws

12.     const_pointer address(const_reference value) const;

    Returns address of non mutable object. Never throws

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

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

14.     void destroy(const pointer & ptr);

    Destroys object. Throws if object's destructor throws

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

16.     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);

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

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

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

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

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

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

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

24.     void set_max_cached_nodes(std::size_t newmax);

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

25.     std::size_t get_max_cached_nodes() const;

    Returns the max cached nodes parameter. Never throws

### `cached_node_allocator` friend functions

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