Class template allocator

boost::interprocess::allocator

Synopsis

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

template<typename T, typename SegmentManager> 
class allocator {
public:
  // types
  typedef SegmentManager                                    segment_manager;
  typedef SegmentManager::void_pointer                      void_pointer;   
  typedef T                                                 value_type;     
  typedef boost::pointer_to_other< cvoid_ptr, T >::type     pointer;        
  typedef boost::pointer_to_other< pointer, const T >::type const_pointer;  
  typedef unspecified                                       reference;      
  typedef unspecified                                       const_reference;
  typedef std::size_t                                       size_type;      
  typedef std::ptrdiff_t                                    difference_type;
  typedef boost::interprocess::version_type< allocator, 2 > version;        
  template<typename T2> 
  struct rebind {
    // types
    typedef allocator< T2, SegmentManager > other;
  };

  // construct/copy/destruct
  allocator(segment_manager *);
  allocator(const allocator &);
  template<typename T2> allocator(const allocator< T2, SegmentManager > &);

  // public member functions
  segment_manager * get_segment_manager() const;
  pointer allocate(size_type, cvoid_ptr = 0) ;
  void deallocate(const pointer &, size_type) ;
  size_type max_size() const;
  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) ;
  pointer address(reference) const;
  const_pointer address(const_reference) const;
  void construct(const pointer &, const_reference) ;
  void construct(const pointer &) ;
  void destroy(const pointer &) ;
};

Description

An STL compatible allocator that uses a segment manager as memory source. The internal pointer type will of the same type (raw, smart) as "typename SegmentManager::void_pointer" type. This allows placing the allocator in shared memory, memory mapped-files, etc...

`allocator` public construct/copy/destruct

```
allocator(segment_manager * segment_mngr);
```
Constructor from the segment manager. Never throws
```
allocator(const allocator & other);
```
Constructor from other allocator. Never throws

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

Constructor from related allocator. Never throws

`allocator` public member functions

segment_manager * get_segment_manager() const;

Returns the segment manager. Never throws

```
pointer allocate(size_type count, cvoid_ptr hint = 0) ;
```
Allocates 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) ;
```
Deallocates memory previously allocated. Never throws
```
size_type max_size() const;
```
Returns the number of elements that could be allocated. Never 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, 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(...)
```
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(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().
```
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 chain) ;
```
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().
```
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) ;
```
Copy construct an object Throws if T's copy constructor throws
```
void construct(const pointer & ptr) ;
```
Default construct an object. Throws if T's default constructor throws
```
void destroy(const pointer & ptr) ;
```
Destroys object. Throws if object's destructor throws

Boost C++ Libraries

Class template allocator

Synopsis

Description

allocator public construct/copy/destruct

allocator public member functions

`allocator` public construct/copy/destruct

`allocator` public member functions