| Home | Libraries | People | FAQ | More

## Class template node_allocator

boost::container::node_allocator

## Synopsis

    // In header: <boost/container/node_allocator.hpp>

    template<typename T, std::size_t NodesPerBlock = NodeAlloc_nodes_per_block>
    class node_allocator {
    public:
      // types
      typedef T                                                      value_type;
      typedef T *                                                    pointer;
      typedef const T *                                              const_pointer;
      typedef ::boost::container::dtl::unvoid_ref< T >::type         reference;
      typedef ::boost::container::dtl::unvoid_ref< const T >::type   const_reference;
      typedef std::size_t                                            size_type;
      typedef std::ptrdiff_t                                         difference_type;
      typedef boost::container::dtl::version_type< self_t, Version > version;

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

      // construct/copy/destruct
      node_allocator() noexcept;
      node_allocator(const node_allocator &) noexcept;
      template<typename T2>
        node_allocator(const node_allocator< T2, NodesPerBlock > &) noexcept;
      ~node_allocator();

      // public member functions
      size_type max_size() const;
      pointer allocate(size_type, const void * = 0);
      void deallocate(const pointer &, size_type) noexcept;
      pointer allocation_command(allocation_type, size_type, size_type &,
                                 pointer &);
      size_type size(pointer) const noexcept;
      pointer allocate_one();
      void allocate_individual(std::size_t, multiallocation_chain &);
      void deallocate_one(pointer) noexcept;
      void deallocate_individual(multiallocation_chain &) noexcept;
      void allocate_many(size_type, std::size_t, multiallocation_chain &);
      void allocate_many(const size_type *, size_type, multiallocation_chain &);
      void deallocate_many(multiallocation_chain &) noexcept;

      // public static functions
      static void deallocate_free_blocks() noexcept;

      // friend functions
      friend void swap(self_t &, self_t &) noexcept;
      friend bool operator==(const node_allocator &, const node_allocator &) noexcept;
      friend bool operator!=(const node_allocator &, const node_allocator &) noexcept;

      // private member functions
      pointer priv_allocation_command(allocation_type, std::size_t, size_type &,
                                      pointer &);
    };

## Description

An STL node allocator that uses a modified DlMalloc as memory source.

This node allocator shares a segregated storage between all instances of node_allocator with equal sizeof(T).

NodesPerBlock is the number of nodes allocated at once when the allocator runs out of nodes

### `node_allocator` public construct/copy/destruct

1.     node_allocator() noexcept;

   Default constructor.

2.     node_allocator(const node_allocator &) noexcept;

   Copy constructor from other `node_allocator`.

3.     template<typename T2>
         node_allocator(const node_allocator< T2, NodesPerBlock > &) noexcept;

   Copy constructor from related `node_allocator`.

4.     ~node_allocator();

   Destructor.

### `node_allocator` public member functions

1.     size_type max_size() const;

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

2.     pointer allocate(size_type count, const void * = 0);

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

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

   Deallocate allocated memory. Never throws

4.     pointer allocation_command(allocation_type command, size_type limit_size,
                                  size_type & prefer_in_recvd_out_size,
                                  pointer & reuse);

5.     size_type size(pointer p) const noexcept;

   Returns maximum the number of objects the previously allocated memory pointed by p can hold.

6.     pointer allocate_one();

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

7.     void allocate_individual(std::size_t num_elements,
                                multiallocation_chain & chain);

   Allocates many elements of size == 1. Elements must be individually deallocated with deallocate_one()

8.     void deallocate_one(pointer p) noexcept;

   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

9.     void deallocate_individual(multiallocation_chain & chain) noexcept;

10.     void allocate_many(size_type elem_size, std::size_t n_elements,
                           multiallocation_chain & chain);

    Allocates many elements of size elem_size. Elements must be individually deallocated with deallocate()

11.     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] Elements must be individually deallocated with deallocate()

12.     void deallocate_many(multiallocation_chain & chain) noexcept;

### `node_allocator` public static functions

1.     static void deallocate_free_blocks() noexcept;

   Deallocates all free blocks of the pool.

### `node_allocator` friend functions

1.     friend void swap(self_t &, self_t &) noexcept;

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

2.     friend bool operator==(const node_allocator &, const node_allocator &) noexcept;

   An allocator always compares to true, as memory allocated with one instance can be deallocated by another instance

3.     friend bool operator!=(const node_allocator &, const node_allocator &) noexcept;

   An allocator always compares to false, as memory allocated with one instance can be deallocated by another instance

### `node_allocator` private member functions

1.     pointer priv_allocation_command(allocation_type command,
                                       std::size_t limit_size,
                                       size_type & prefer_in_recvd_out_size,
                                       pointer & reuse);