dune-common 2.9.0
Loading...
Searching...
No Matches
Classes | Functions
Allocators

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
nThe number of objects to allocate. Has to be one!
hintIgnored 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
pPointer to the object.
valueThe 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
nThe number of objects to free. Has to be one!
pPointer 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
pPointer to the object.

◆ free()

template<class T , std::size_t S>
void Dune::Pool< T, S >::free ( void *  o)
inline

Free an object.

Parameters
oThe 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.