EventProcessor Class Reference
[Event Interface., Execution Engine]

#include </home/sspr/src/www/orocos-1.0/export/build/orocos-rtt-1.2.2/build/rtt/EventProcessor.hpp>

Inheritance diagram for EventProcessor:

List of all members.

---

Detailed Description

An Asynchronous Event Processor, which catches events and executes the asynchronous callbacks in its RunnableInterface::step().

This class is mostly used internally by Orocos, but users can use it to process asynchronous callbacks in their own implementation. The EventProcessor is an argument in the Event's asynchronous connect method.

Changing the Event Processing Policy.

The default policy of the EventProcessor is to process all asynchronous callbacks in step(). In order to change the processing of the asynchronous events, subclass this class and override step() or other virtual functions. The BlockingEventProcessor is an example of an EventProcessor with a different policy, and can be subclassed in turn.

See also:

CompletionProcessor

Public Types
enum	AsynStorageType { OnlyFirst, OnlyLast }
	For Asynchronous callbacks, this enum defines how the arguments are stored in case of an overrun, ie, when the event is fired multiple times, before the asynchronous callback can be called. More...
Public Member Functions
	EventProcessor ()
	Create a periodic EventProcessor.
bool	initialize ()
	The method that will be called before the first periodical execution of step() ( or non periodical execution of loop() ), when the thread is started.
void	step ()
	The method that will be periodically executed when this class is run in a periodic thread.
void	finalize ()
	The method that will be called after the last periodical execution of step() ( or non periodical execution of loop() ), when the RunnableInterface is stopped.
bool	breakLoop ()
	Force the loop() method to return.
template<class SignalType>
Handle	connect (const typename SignalType::SlotFunction &f, SignalType &sig, AsynStorageType t)
	Connect a function to an Event and process upon each event the function in this event processor.
template<class SignalType>
Handle	setup (const typename SignalType::SlotFunction &f, SignalType &sig, AsynStorageType t)
	Setup the processing of an asynchronous event.
ActivityInterface *	getActivity () const
	Query for the task this interface is run in.
virtual void	setActivity (ActivityInterface *task)
	Set the task this interface is run in.
virtual void	loop ()
	The method that will be executed once when this class is run in a non periodic thread.
ThreadInterface *	getThread () const
	Get the thread this object is run in.
virtual void	setThread (ThreadInterface *t)
	Set the thread this object will be run in.
Protected Types
typedef ListLockFree< detail::EventCatcher * >	List
	The EC is released when the connection it is used in is deleted *and* it is removed from this vector.
Protected Member Functions
void	destroyed (detail::EventCatcher *ec)
Protected Attributes
List	catchers
Friends
class	detail::EventCatcher

---

Member Enumeration Documentation

enum AsynStorageType

For Asynchronous callbacks, this enum defines how the arguments are stored in case of an overrun, ie, when the event is fired multiple times, before the asynchronous callback can be called.

Enumerator:

OnlyLast

< Only call the callback once with the last fire() call's arguments

---

Member Function Documentation

Handle connect	(	const typename SignalType::SlotFunction &	f,
		SignalType &	sig,
		AsynStorageType	t
	)			[inline]

Connect a function to an Event and process upon each event the function in this event processor.

The returned handle holds the connection between f and sig.

Parameters:

	f	will be called within this EventProcessor when sig is emitted.
	sig	The Event to which f will react.
	t	specifies the policy in case of over-runs. That is, when sig is emitted multiple times before f could be called.

Returns:

An connected handle. Call Handle::disconnect() upon this object in order to remove the link between f and sig.

Handle setup	(	const typename SignalType::SlotFunction &	f,
		SignalType &	sig,
		AsynStorageType	t
	)			[inline]

Setup the processing of an asynchronous event.

The returned handle does not yet connect f and sig. Use Handle::connect().

Parameters:

	f	will be called within this EventProcessor when sig is emitted.
	sig	The Event to which f will react.
	t	specifies the policy in case of over-runs. That is, when sig is emitted multiple times before f could be called.

Returns:

An unconnected handle. Call Handle::connect() upon this object in order to activate the link between f and sig.

ActivityInterface * getActivity

(

)

const [inline, inherited]

Query for the task this interface is run in.

Zero denotes that no task is present to run it, and hence no detailed information is available.

Returns:

The Activity which runs this RunnableInterface.

virtual void setActivity

(

ActivityInterface *

task

)

[virtual, inherited]

Set the task this interface is run in.

A Zero means no task is running it.

Parameters:

task

The ActivityInterface running this interface.

Reimplemented in ExecutionEngine.

virtual void loop

(

)

[virtual, inherited]

The method that will be executed once when this class is run in a non periodic thread.

The default implementation calls step() once.

ThreadInterface* getThread

(

)

const [inherited]

Get the thread this object is run in.

Returns:

a pointer to the thread or 0 if not run by a thread.

---

The documentation for this class was generated from the following file:

• rtt/EventProcessor.hpp

---