CLASS TEMPLATE A(3)

NAME
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 allocator< T, SegmentManager >                              self_t;                 // @ private:
  typedef segment_manager::void_pointer                               aux_pointer_t;
  typedef boost::pointer_to_other< aux_pointer_t, const void >::type  cvoid_ptr;
  typedef boost::pointer_to_other< cvoid_ptr, segment_manager >::type alloc_ptr_t;
  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;
  typedef unspecified                                                 multiallocation_chain;  // @
  // member classes/structs/unions
  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 > &);
  template<typename T2, typename SegmentManager2>
    allocator& operator=(const allocator< T2, SegmentManager2 > &);
  allocator& operator=(const allocator &);
  // 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 &);
  // friend functions
  friend void swap(self_t &, self_t &);
  alloc_ptr_t mp_mngr;
};

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

    1.

    allocator(segment_manager * segment_mngr);

    Constructor from the segment manager. Never throws

    2.

    allocator(const allocator & other);

    Constructor from other allocator. Never throws

    3.

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

    Constructor from related allocator. Never throws

    4.

    template<typename T2, typename SegmentManager2>
      allocator& operator=(const allocator< T2, SegmentManager2 > &);

    5.

    allocator& operator=(const allocator &);

  allocator public member functions

    1.

    segment_manager * get_segment_manager() const;

    Returns the segment manager. Never throws

    2.

    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

    3.

    void deallocate(const pointer & ptr, size_type);

    Deallocates memory previously allocated. Never throws

    4.

    size_type max_size() const;

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

    5.

    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.

    6.

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

    7.

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

    8.

    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

    9.

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

    10.

    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

    11.

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

    12.

    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

    13.

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

    14.

    pointer address(reference value) const;

    Returns address of mutable object. Never throws

    15.

    const_pointer address(const_reference value) const;

    Returns address of non mutable object. Never throws

    16.

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

    Copy construct an object Throws if T's copy constructor throws

    17.

    void construct(const pointer & ptr);

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

    18.

    void destroy(const pointer & ptr);

    Destroys object. Throws if object's destructor throws

  allocator friend functions

    1.

    friend void swap(self_t & alloc1, self_t & alloc2);

    Swap segment manager. Does not throw. If each allocator is placed in different memory segments, the result is undefined.