RTT::ListLocked< T > Class Template Reference

A simple lock-based list implementation to append or erase data of type T. More...

#include <rtt/ListLocked.hpp>

List of all members.

Public Types

typedef T value_t

Public Member Functions

 ListLocked (unsigned int lsize, unsigned int unused=0)
 Create a lock-based list wich can store lsize elements.
size_t capacity () const
size_t size () const
bool empty () const
void grow (size_t items=1)
 Grow the capacity to contain at least n additional items.
void shrink (size_t items=1)
 Shrink the capacity with at most n items.
void reserve (size_t lsize)
 Reserve a capacity for this list.
void clear ()
bool append (value_t item)
 Append a single value to the list.
value_t front () const
 Returns the first element of the list.
value_t back () const
 Returns the last element of the list.
size_t append (const std::vector< T > &items)
 Append a sequence of values to the list.
bool erase (value_t item)
 Erase a value from the list.
template<class Function >
void apply (Function func)
 Apply a function to the elements of the whole list.
template<class Function >
value_t find_if (Function func, value_t blank=value_t())
 Find an item in the list such that func( item ) == true.

Detailed Description

template<class T>
class RTT::ListLocked< T >

A simple lock-based list implementation to append or erase data of type T.

Note:
The mutex used by this implementation is recursive in order to allow apply() to call apply() recursively. Erasing self (using clear() or erase()) from within apply() is not supported and may lead to abnormal program termination.
Parameters:
T The value type to be stored in the list. Example : ListLocked is a list which holds values of type A.

Definition at line 33 of file ListLocked.hpp.


Constructor & Destructor Documentation

template<class T >
RTT::ListLocked< T >::ListLocked ( unsigned int  lsize,
unsigned int  unused = 0 
) [inline]

Create a lock-based list wich can store lsize elements.

Parameters:
lsize the initial capacity of the list. '

Definition at line 57 of file ListLocked.hpp.


Member Function Documentation

template<class T >
size_t RTT::ListLocked< T >::append ( const std::vector< T > &  items  )  [inline]

Append a sequence of values to the list.

Parameters:
items the values to append.
Returns:
the number of values written (may be less than items.size())

Definition at line 175 of file ListLocked.hpp.

template<class T >
bool RTT::ListLocked< T >::append ( value_t  item  )  [inline]

Append a single value to the list.

Parameters:
d the value to write
Returns:
false if the list is full.

Definition at line 143 of file ListLocked.hpp.

template<class T >
template<class Function >
void RTT::ListLocked< T >::apply ( Function  func  )  [inline]

Apply a function to the elements of the whole list.

Parameters:
func The function to apply.
Note:
func may not call clear() or erase() on the current element of this list.

Definition at line 205 of file ListLocked.hpp.

template<class T >
bool RTT::ListLocked< T >::erase ( value_t  item  )  [inline]

Erase a value from the list.

Parameters:
item is to be erased from the list.
Returns:
true if found and erased.

Definition at line 191 of file ListLocked.hpp.

template<class T >
template<class Function >
value_t RTT::ListLocked< T >::find_if ( Function  func,
value_t  blank = value_t() 
) [inline]

Find an item in the list such that func( item ) == true.

Parameters:
blank The value to return if not found.
Returns:
The item that matches func(item) or blank if none matches.

Definition at line 219 of file ListLocked.hpp.

template<class T >
void RTT::ListLocked< T >::grow ( size_t  items = 1  )  [inline]

Grow the capacity to contain at least n additional items.

This method tries to avoid too much re-allocations, by growing a bit more than required every N invocations and growing nothing in between.

Parameters:
items The number of items to at least additionally reserve.

Definition at line 97 of file ListLocked.hpp.

template<class T >
void RTT::ListLocked< T >::reserve ( size_t  lsize  )  [inline]

Reserve a capacity for this list.

Parameters:
lsize the minimal number of items this list will be able to hold. Will not drop below the current capacity() and this method will do nothing if lsize < this->capacity().

Definition at line 124 of file ListLocked.hpp.

template<class T >
void RTT::ListLocked< T >::shrink ( size_t  items = 1  )  [inline]

Shrink the capacity with at most n items.

This method does not actually free memory, it just prevents a (number of) subsequent grow() invocations to allocate more memory.

Parameters:
items The number of items to at most remove from the capacity.

Definition at line 113 of file ListLocked.hpp.


The documentation for this class was generated from the following file:
Generated on Thu Dec 23 13:22:43 2010 for Orocos Real-Time Toolkit by  doxygen 1.6.3