| 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 unspecified    reference;
      typedef unspecified    const_reference;
      typedef std::size_t    size_type;
      typedef std::ptrdiff_t difference_type;
      typedef unspecified    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;
      std::pair< pointer, bool >
      allocation_command(allocation_type, size_type, size_type, size_type &,
                         pointer = 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
      std::pair< pointer, bool >
      priv_allocation_command(allocation_type, std::size_t, std::size_t,
                              std::size_t &, void *);
    };

## 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.     std::pair< pointer, bool >
       allocation_command(allocation_type command, size_type limit_size,
                          size_type preferred_size, size_type & received_size,
                          pointer reuse = pointer());

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.     std::pair< pointer, bool >
       priv_allocation_command(allocation_type command, std::size_t limit_size,
                               std::size_t preferred_size,
                               std::size_t & received_size, void * reuse_ptr);