RTT::List< T > Class Template Reference

This object represents the default queue implementation used by Orocos objects. More...

#include <rtt/List.hpp>

Inheritance diagram for RTT::List< T >:
RTT::ListLockFree< T >

List of all members.

Public Types

typedef T value_t

Public Member Functions

 List (int qsize, int t=ORONUM_OS_MAX_THREADS)
 Create a queue of fixed size.
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.
size_t append (const std::vector< T > &items)
 Append a sequence of values 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.
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 >
void apply_and_blank (Function func, value_t blank)
 Apply a function to the non-blanked elements of the list.
bool erase_and_blank (value_t item, value_t blank)
 Erase an element from the list and blank it if possible.
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.

Public Attributes

const unsigned int MAX_THREADS
 The maximum number of threads.

Detailed Description

template<class T>
class RTT::List< T >

This object represents the default queue implementation used by Orocos objects.

Definition at line 25 of file List.hpp.


Constructor & Destructor Documentation

template<class T>
RTT::List< T >::List ( int  qsize,
int  t = ORONUM_OS_MAX_THREADS 
) [inline]

Create a queue of fixed size.

Optionally, add the number of threads that may concurrently access this queue.

Definition at line 38 of file List.hpp.


Member Function Documentation

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

Append a sequence of values to the list.

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

Definition at line 369 of file ListLockFree.hpp.

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

Append a single value to the list.

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

Definition at line 316 of file ListLockFree.hpp.

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

Apply a function to the elements of the whole list.

Parameters:
func The function to apply.

Definition at line 443 of file ListLockFree.hpp.

template<class T>
template<class Function >
void RTT::ListLockFree< T >::apply_and_blank ( Function  func,
value_t  blank 
) [inline, inherited]

Apply a function to the non-blanked elements of the list.

If during an apply_and_blank, the erase_and_blank function is called, that element will not be subject to func if not yet processed. You must not call this function concurrently from multiple threads.

Parameters:
func The function to apply.
blank The 'blank' item. Each item of this list will be compared to this item using operator==(), if it matches, it is considered blank, and func is not applied.
See also:
erase_and_blank
Deprecated:
This complicated function is nowhere used.

Definition at line 469 of file ListLockFree.hpp.

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

Erase a value from the list.

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

Definition at line 404 of file ListLockFree.hpp.

Referenced by RTT::ListLockFree< detail::EventCatcher * >::erase_and_blank().

template<class T>
bool RTT::ListLockFree< T >::erase_and_blank ( value_t  item,
value_t  blank 
) [inline, inherited]

Erase an element from the list and blank it if possible.

If during an apply_and_blank, the erase_and_blank function is called, that element will not be subject to func if not yet processed. You may call this function concurrently from multiple threads.

Warning:
It is possible that item is being processed within apply_and_blank. In that case the 'blank' operation has no effect.
Parameters:
item The item to erase from the list.
blank The 'blank' item to use to blank item from the list.
See also:
apply_and_blank
Deprecated:
This complicated function is nowhere used.

Definition at line 512 of file ListLockFree.hpp.

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

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 539 of file ListLockFree.hpp.

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

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 207 of file ListLockFree.hpp.

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

Reserve a capacity for this list.

If you wish to invoke this method concurrently, guard it with a mutex. The other methods may be invoked concurrently with this method.

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 233 of file ListLockFree.hpp.

Referenced by RTT::ListLockFree< detail::EventCatcher * >::grow().

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

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 220 of file ListLockFree.hpp.


Member Data Documentation

template<class T>
const unsigned int RTT::ListLockFree< T >::MAX_THREADS [inherited]

The maximum number of threads.

The number of threads which may concurrently access this buffer.

Definition at line 89 of file ListLockFree.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