Loading...
Searching...
No Matches
Allocators
Common

Implementations of the STL allocator concept. More...

Collaboration diagram for Allocators:

## Classes

class | Dune::AlignedAllocator< T, Alignment >
| Allocators which guarantee alignment of the memory. More...
class | Dune::MallocAllocator< T >
| Allocators implementation which simply calls malloc/free. More...
class | Dune::Pool< T, s >
| A memory pool of objects. More...
class | Dune::PoolAllocator< T, s >
| An allocator managing a pool of objects for reuse. More...
class | Dune::PoolAllocator< void, s >

## Functions

template<typename T1, std::size_t t1, typename T2, std::size_t t2>
bool | Dune::operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T1, std::size_t t1, typename T2, std::size_t t2>
bool | Dune::operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T, std::size_t t1, std::size_t t2>
bool | Dune::operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T, std::size_t t1, std::size_t t2>
bool | Dune::operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T, std::size_t t1, std::size_t t2>
bool | Dune::operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T, std::size_t t1, std::size_t t2>
bool | Dune::operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<std::size_t t1, std::size_t t2>
bool | Dune::operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
template<std::size_t t1, std::size_t t2>
bool | Dune::operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
| Dune::Pool< T, s >::Pool ()
| Constructor.
| Dune::Pool< T, s >::~Pool ()
| Destructor.
void | Dune::Pool< T, s >::print (std::ostream &os)
| Print elements in pool for debugging.
void | Dune::Pool< T, s >::free (void *o)
| Free an object.
void * | Dune::Pool< T, s >::allocate ()
| Get a new or recycled object.
| Dune::PoolAllocator< T, s >::PoolAllocator ()
| Constructor.
pointer | Dune::PoolAllocator< T, s >::allocate (std::size_t n, const_pointer hint=0)
| Allocates objects.
void | Dune::PoolAllocator< T, s >::deallocate (pointer p, std::size_t n)
| Free objects.
void | Dune::PoolAllocator< T, s >::construct (pointer p, const_reference value)
| Construct an object.
void | Dune::PoolAllocator< T, s >::destroy (pointer p)
| Destroy an object without freeing memory.

## Detailed Description

Implementations of the STL allocator concept.

## Function Documentation

## allocate() [1/2]

template<class T, std::size_t S>

void * Dune::Pool< T, S >::allocate | ( |  | ) |

inline

Get a new or recycled object.

Returns
  A pointer to the object memory.

## allocate() [2/2]

template<class T, std::size_t s>

PoolAllocator< T, s >::pointer Dune::PoolAllocator< T, s >::allocate | ( | std::size_t | n,
|  | const_pointer | hint = 0 )

inline

Allocates objects.

Parameters

  n | The number of objects to allocate. Has to be one!
  hint | Ignored hint.

Returns
  A pointer tp the allocated elements.

## construct()

template<class T, std::size_t s>

void Dune::PoolAllocator< T, s >::construct | ( | pointer | p,
|  | const_reference | value )

inline

Construct an object.

Parameters

  p | Pointer to the object.
  value | The value to initialize it to.

## deallocate()

template<class T, std::size_t s>

void Dune::PoolAllocator< T, s >::deallocate | ( | pointer | p,
|  | std::size_t | n )

inline

Free objects.

Does not call the destructor!

Parameters

  n | The number of objects to free. Has to be one!
  p | Pointer to the first object.

## destroy()

template<class T, std::size_t s>

void Dune::PoolAllocator< T, s >::destroy | ( | pointer | p | ) |

inline

Destroy an object without freeing memory.

Parameters

  p | Pointer to the object.

## free()

template<class T, std::size_t S>

void Dune::Pool< T, S >::free | ( | void * | o | ) |

inline

Free an object.

Parameters

  o | The pointer to memory block of the object.

## operator!=() [1/4]

template<typename T, std::size_t t1, std::size_t t2>

bool Dune::operator!= | ( | const PoolAllocator< T, t1 > & | p1,
|  | const PoolAllocator< T, t2 > & | p2 )

## operator!=() [2/4]

template<typename T1, std::size_t t1, typename T2, std::size_t t2>

bool Dune::operator!= | ( | const PoolAllocator< T1, t1 > & | ,
|  | const PoolAllocator< T2, t2 > & | )

## operator!=() [3/4]

template<typename T, std::size_t t1, std::size_t t2>

bool Dune::operator!= | ( | const PoolAllocator< void, t1 > & | ,
|  | const PoolAllocator< T, t2 > & | )

## operator!=() [4/4]

template<std::size_t t1, std::size_t t2>

bool Dune::operator!= | ( | const PoolAllocator< void, t1 > & | p1,
|  | const PoolAllocator< void, t2 > & | p2 )

## operator==() [1/4]

template<typename T, std::size_t t1, std::size_t t2>

bool Dune::operator== | ( | const PoolAllocator< T, t1 > & | p1,
|  | const PoolAllocator< T, t2 > & | p2 )

## operator==() [2/4]

template<typename T1, std::size_t t1, typename T2, std::size_t t2>

bool Dune::operator== | ( | const PoolAllocator< T1, t1 > & | ,
|  | const PoolAllocator< T2, t2 > & | )

## operator==() [3/4]

template<typename T, std::size_t t1, std::size_t t2>

bool Dune::operator== | ( | const PoolAllocator< void, t1 > & | ,
|  | const PoolAllocator< T, t2 > & | )

## operator==() [4/4]

template<std::size_t t1, std::size_t t2>

bool Dune::operator== | ( | const PoolAllocator< void, t1 > & | p1,
|  | const PoolAllocator< void, t2 > & | p2 )

## Pool()

template<class T, std::size_t S>

Dune::Pool< T, S >::Pool | ( |  | ) |

inline

Constructor.

## PoolAllocator()

template<class T, std::size_t s>

Dune::PoolAllocator< T, s >::PoolAllocator | ( |  | ) |

inline

Constructor.

## print()

template<class T, std::size_t S>

void Dune::Pool< T, S >::print | ( | std::ostream & | os | ) |

inline

Print elements in pool for debugging.

## ~Pool()

template<class T, std::size_t S>

Dune::Pool< T, S >::~Pool | ( |  | ) |

inline

Destructor.