Orocos Real-Time Toolkit  2.6.0
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Friends
RTT::TaskContext Class Reference

The TaskContext is the C++ representation of an Orocos component. More...

#include <rtt/TaskContext.hpp>

Inheritance diagram for RTT::TaskContext:
RTT::base::TaskCore RTT::corba::TaskContextProxy

List of all members.

Public Types

typedef std::vector< std::string > PeerList
 A list of Peer TaskContext names.
enum  TaskState {
  Init, PreOperational, FatalError, Exception,
  Stopped, Running, RunTimeError
}
 Describes the different states a component can have. More...

Public Member Functions

 TaskContext (const std::string &name, TaskState initial_state=Stopped)
 Create a TaskContext.
 TaskContext (const std::string &name, ExecutionEngine *parent, TaskState initial_state=Stopped)
 Create a TaskContext.
virtual const std::string & getName ()
 Returns the name of this TaskContext.
bool setActivity (base::ActivityInterface *new_act)
 Sets the activity of this TaskContext.
base::ActivityInterfacegetActivity ()
 Get a pointer to the activity running this component.
template<typename T >
T * getActivity ()
 Get a pointer to the activity running this component.
virtual void clear ()
 Clear the complete interface of this Component.
virtual bool ready ()
 Checks the validity of this TaskContext.
virtual bool start ()
 This method starts the execution of the updateHook() with each trigger or period.
virtual bool stop ()
 This method stops the execution of updateHook() of this component.
virtual TaskState getTaskState () const
 Returns the current state of the TaskCore.
virtual TaskState getTargetState () const
 Returns the state this TaskCore is going to, or in case no transition is taking place, returns getTaskState().
void setExecutionEngine (ExecutionEngine *engine)
 Use this method to re-set the execution engine of this task core.
const ExecutionEngineengine () const
 Get a const pointer to the ExecutionEngine of this Task.
ExecutionEngineengine ()
 Get a pointer to the ExecutionEngine of this Task.
Peer-to-Peer functions

These functions are used to setup and manage peer-to-peer networks of TaskContext objects.

virtual bool addPeer (TaskContext *peer, std::string alias="")
 Add a one-way connection from this task to a peer task.
virtual void removePeer (const std::string &name)
 Remove a one-way connection from this task to a peer task.
virtual void removePeer (TaskContext *peer)
 Remove a one-way connection from this task to a peer task.
virtual bool connectPeers (TaskContext *peer)
 Add a two-way connection from this task to a peer task.
virtual void disconnect ()
 Disconnect this TaskContext from it's peers and ports.
virtual void disconnectPeers (const std::string &name)
 Remove a two-way connection from this task to a peer task.
virtual PeerList getPeerList () const
 Return a standard container which contains all the Peer names of this TaskContext.
virtual bool hasPeer (const std::string &peer_name) const
 Return true if it knows a peer by that name.
virtual TaskContextgetPeer (const std::string &peer_name) const
 Get a pointer to a peer of this task.
Services

These functions are used to create and manage services.

Use provides() or requires() to access the Service or ServiceRequester objects that contain all service related functions.

Service::shared_ptr provides ()
 Returns this Service.
Service::shared_ptr provides (const std::string &service_name)
 Returns a sub-Service which resorts under this Service.
ServiceRequesterrequires ()
 Returns the object that manages which methods this Task requires to be implemented by another task.
ServiceRequesterrequires (const std::string &service_name)
 Returns the object that manages which methods this Task requires to be implemented by another service.
virtual bool connectServices (TaskContext *peer)
 Connects all requires/provides services of this component to these of a peer.
template<class ServiceType >
boost::shared_ptr< ServiceType > getProvider (const std::string &name)
 Use this method to be able to make OperationCaller calls to services provided by this component.
bool loadService (const std::string &service_name)
 Use this method to load a service known to RTT into this component.
Operations

Adding and getting operations from the TaskContext interface.

These functions all forward to the Service representing this TaskContext. Use provides() to access the complete Service interface of this TaskContext.

template<class Signature >
Operation< Signature > & addOperation (Operation< Signature > &op)
 Add an operation object to the interface.
template<class Func , class Service >
Operation< typename
internal::GetSignature< Func >
::Signature > & 
addOperation (const std::string name, Func func, Service *serv, ExecutionThread et=ClientThread)
 Adds a C++ function as an operation.
template<class Signature >
Operation< Signature > & addOperation (const std::string name, Signature *func, ExecutionThread et=ClientThread)
 Adds a C function as an operation.
OperationInterfacePartgetOperation (std::string name)
 Get a previously added operation for use in a C++ OperationCaller object.
OperationInterfaceoperations ()
 Returns the operations of this TaskContext as an OperationInterface.
Attributes

Adding and getting attributes from the TaskContext interface.

These functions all forward to the Service representing this TaskContext. Use attributes() to access the complete ConfigurationInterface interface of this TaskContext.

template<class T >
bool addAttribute (const std::string &name, T &attr)
 Adds a variable of any type as read/write attribute to the attribute interface.
template<class T >
bool addConstant (const std::string &name, const T &attr)
 Adds a variable of any type as read-only attribute to the attribute interface.
bool addAttribute (base::AttributeBase &a)
 Add an base::AttributeBase which remains owned by the user.
base::AttributeBasegetAttribute (const std::string &name) const
 Adds a variable of any type as read/write attribute to the attribute interface.
ConfigurationInterfaceattributes ()
 Returns the attributes of this TaskContext as an ConfigurationInterface.
Properties

Adding and getting properties from the TaskContext interface.

These functions all forward to the Service representing this TaskContext. Use properties() to access the complete PropertyBag interface of this TaskContext.

template<class T >
Property< T > & addProperty (const std::string &name, T &attr)
 Adds a variable of any type as a property to the attribute interface.
bool addProperty (base::PropertyBase &pb)
 Add an base::PropertyBase as a property.
base::PropertyBasegetProperty (const std::string &name) const
 Get a Property with name name.
PropertyBagproperties ()
 Returns the properties of this TaskContext as a PropertyBag.
Operations

These TaskCore functions are exported in a TaskContext as script methods and are for configuration, starting and stopping its ExecutionEngine.

virtual bool configure ()
 This method instructs the component to (re-)read configuration data and try to enter the Stopped state.
virtual bool activate ()
 This method starts the ExecutionEngine of this component in case it was not running.
virtual bool cleanup ()
 This method instructs a stopped component to enter the pre-operational state again.
virtual bool isConfigured () const
 Inspect if the component is configured, i.e.
virtual bool isActive () const
 Inspect if the component's ExecutionEngine is processing requests.
virtual bool isRunning () const
 Inspect if the component is in the Running or RunTimeError state.
virtual Seconds getPeriod () const
 Get the configured execution period of this component.
virtual bool setPeriod (Seconds s)
 Sets the period of this component.
virtual unsigned getCpuAffinity () const
 Get the configured cpu affinity of this component.
virtual bool setCpuAffinity (unsigned cpu)
 Sets the cpu affinity of this component.
virtual bool inFatalError () const
 Inspect if the component is in the FatalError state.
virtual bool inException () const
 Inspect if the component is in the Exception state.
virtual bool inRunTimeError () const
 Inspect if the component is in the RunTimeError state.
virtual bool update ()
 Invoke this method to execute the ExecutionEngine and the update() method.
virtual bool trigger ()
 Invoke this method to trigger the thread of this TaskContext to execute its ExecutionEngine and the update() method.
virtual void error ()
 Call this method in a Running state to indicate a run-time error condition.
virtual bool recover ()
 Call this method in a RunTimeError or Exception state to indicate that the run-time error conditions are gone and nominal operation is resumed.

Protected Member Functions

void forceActivity (base::ActivityInterface *new_act)
 Forces the current activity to become new_act, even if this TaskContext is still running.
virtual bool configureHook ()
 Implement this method such that it contains the code which will be executed when configure() is called.
virtual void cleanupHook ()
 Implement this method such that it contains the code which will be executed when cleanup() is called.
virtual bool startHook ()
 Implement this method such that it contains the code which will be executed when start() is called.
virtual void updateHook ()
 Function where the user must insert his 'application' code.
virtual bool breakUpdateHook ()
 Implement this function if your code might block for long times inside the updateHook() function.
virtual void errorHook ()
 Implement this method to contain code that must be executed in the RunTimeError state, instead of updateHook().
virtual void exceptionHook ()
 Implement this method to contain code that must be executed when transitioning to the Exception state.
virtual void stopHook ()
 Implement this method such that it contains the code which will be executed when stop() is called.
virtual void fatal ()
 Call this method from any place to indicate that this component encountered a fatal error.
virtual void exception ()
 Call this method to indicate a run-time exception happend.

Protected Attributes

ExecutionEngineee
 The execution engine which calls update() and processes our commands, events etc.
TaskState mTaskState

Friends

class DataFlowInterface
class ::RTT::ExecutionEngine

Ports

These functions serve to manage ports and data flow connections.

Use ports() to access the complete DataFlowInterface functionality of this TaskContext.

typedef boost::function< void(base::PortInterface *) SlotFunction )
 Name and add a Port to the interface of this task and add a Service with the same name of the port.
base::PortInterfaceaddPort (const std::string &name, base::PortInterface &port)
 Name and add a Port to the interface of this task and add a Service with the same name of the port.
base::PortInterfaceaddPort (base::PortInterface &port)
 Add a Port to the interface of this task and add a Service with the same name of the port.
base::InputPortInterfaceaddEventPort (const std::string &name, base::InputPortInterface &port, SlotFunction callback=SlotFunction())
 Name and add an Event triggering Port to the interface of this task and add a Service with the same name of the port.
base::InputPortInterfaceaddEventPort (base::InputPortInterface &port, SlotFunction callback=SlotFunction())
 Add an Event triggering Port to the interface of this task and add a Service with the same name of the port.
base::PortInterfacegetPort (const std::string &name) const
 Get a port of this Component.
DataFlowInterfaceports ()
 Get the Data flow ports of this task.
const DataFlowInterfaceports () const
 Get the Data flow ports of this task.
virtual bool connectPorts (TaskContext *peer)
 Add a data flow connection from this task's ports to a peer's ports.

Detailed Description

The TaskContext is the C++ representation of an Orocos component.

It defines which services it provides and requires and which ports are inputs and outputs. It can be configured through the means of properties.

TaskContext interface
You can define the interface of a TaskContext by adding interface primitives. These are (data flow) ports, (configuration) properties and operations (functions). Setting up the interface is explained at length in the Orocos Component Builder's Manual.
TaskContext state behaviour
When a TaskContext is created it defaults to the 'Stopped' state or the 'PreOperational' state. If it is 'Stopped', it can be start()'ed. If it is 'PreOperational', it must first be configure()'d before it can be started. You can choose between both using the constructor.
See also:
TaskState (in base::TaskCore) for a detailed explanation.
Executing a TaskContext
In order to run the ExecutionEngine, the ExecutionEngine must be run by an base::ActivityInterface implementation. As long as there is no activity or the activity is not started, this TaskContext will not accept any asynchronous invocations, nor execute programs or state machines.
Connecting TaskContexts
TaskContexts are connected using the unidirectional addPeer() or bidirectional RTT::connectPeers() methods. These methods only allow 'peer' TaskContexts to use each other's interface. Use RTT::connectPorts() to setup the data connections between data ports. In order to disconnect this task from its peers, use disconnect(), which will disconnect all the Data Flow Ports and remove this object from its Peers.

In day-to-day use, TaskContexts are connected using the OCL::DeploymentComponent and an XML file or script.

Definition at line 93 of file TaskContext.hpp.


Member Typedef Documentation

typedef boost::function<void(base::PortInterface*) RTT::TaskContext::SlotFunction)

Name and add a Port to the interface of this task and add a Service with the same name of the port.

Parameters:
nameThe name to give to the port.
portThe port to add.

Definition at line 537 of file TaskContext.hpp.


Member Enumeration Documentation

Describes the different states a component can have.

When a TaskContext is being constructed, it is in the Init state. After the construction ends, the component arrives in the PreOperational (additional configuration required) or the Stopped (ready to run) state. Invoking start() will make a transition to the Running state and stop() back to the Stopped state. The Running state executes updateHook(). Finally, there is an FatalError state, in which the component can enter by calling the protected method fatal(). In this state, the ExecutionEngine is stopped and updateHook() is no longer called. The object should then be disposed by a supervision system.

Next to the fatal error, one run-time error level is available in the Running state as well. This level allows 'automatic' recovery by the component in case the problem is temporal. In case of problems, one may call the protected method error() when the component is Running. The component will enter the RunTimeError state and will cause the errorHook() to be called instead of updateHook(). When recover() is called, this run-time error state is left and the nominal Running state is entered again.

In order to check if these transitions are allowed, hook functions are executed, which can be filled in by the component builder.

  • A transition from PreOperational to Stopped is checked by calling the configureHook() method. If this method returns true, the transition is made, otherwise, the state remains PreOperational.
  • A transition from Stopped to Running is checked by calling the startHook() method. If this method returns true, the transition is made, otherwise, the state remains Stopped.
  • A transition from Running to Stopped is always allowed and the stopHook() method is called to inform the component of this transtion.
  • A transition from Stopped to PreOperational is always allowed and the cleanupHook() method is called to inform the component of this transtion.
Enumerator:
Init 

The state during component construction.

PreOperational 

The state indicating additional configuration is required.

FatalError 

The state indicating the component encountered a fatal error and is unable to execute.

Exception 

The state indicating the component encountered a C++ exception.

Stopped 

The state indicating the component is ready to run.

Running 

The state indicating the component is running [green].

RunTimeError 

The state indicating that a run-time error has occured [red] and needs attention.

Definition at line 99 of file TaskCore.hpp.


Constructor & Destructor Documentation

RTT::TaskContext::TaskContext ( const std::string &  name,
TaskState  initial_state = Stopped 
)

Create a TaskContext.

It's ExecutionEngine will be newly constructed with private processing of commands, events, programs and state machines.

Parameters:
nameThe name of this component.
initial_stateProvide the PreOperational parameter flag here to force users in calling configure(), before they call start().

Definition at line 70 of file TaskContext.cpp.

RTT::TaskContext::TaskContext ( const std::string &  name,
ExecutionEngine parent,
TaskState  initial_state = Stopped 
)

Create a TaskContext.

Its commands programs and state machines are processed by parent. Use this constructor to share execution engines among task contexts, such that the execution of their functionality is serialised (executed in the same thread).

Parameters:
nameThe name of this component.
initial_stateProvide the PreOperational parameter flag here to force users in calling configure(), before they call start().

Definition at line 83 of file TaskContext.cpp.


Member Function Documentation

bool RTT::TaskCore::activate ( ) [virtual, inherited]

This method starts the ExecutionEngine of this component in case it was not running.

Normally, it is always running. There is no way to deactivate it from the public interface.

Returns:
true if the ExecutionEngine is running (again) and false if it could not be started.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 239 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), RTT::base::TaskCore::isActive(), and RTT::base::ActivityInterface::start().

template<class T >
bool RTT::TaskContext::addAttribute ( const std::string &  name,
T &  attr 
) [inline]

Adds a variable of any type as read/write attribute to the attribute interface.

An Alias is created which causes contents of the attr variable always to be in sync with the contents of the attribute object in the interface.

Parameters:
nameThe name of this attribute
attrThe variable that will be aliased.

Definition at line 411 of file TaskContext.hpp.

Add an base::AttributeBase which remains owned by the user.

This is a low-level function that can be used if you already created an Attribute object that does not belong yet to a service.

Parameters:
aremains owned by the user, and becomes served by the repository.

Definition at line 437 of file TaskContext.hpp.

template<class T >
bool RTT::TaskContext::addConstant ( const std::string &  name,
const T &  attr 
) [inline]

Adds a variable of any type as read-only attribute to the attribute interface.

An Alias is created which causes contents of the attribute always to be in sync with the contents of attr, but it can only be read through the interface.

Parameters:
nameThe name of this attribute
attrThe variable that will be aliased.

Definition at line 424 of file TaskContext.hpp.

base::InputPortInterface& RTT::TaskContext::addEventPort ( const std::string &  name,
base::InputPortInterface port,
SlotFunction  callback = SlotFunction() 
) [inline]

Name and add an Event triggering Port to the interface of this task and add a Service with the same name of the port.

Parameters:
nameThe name to give to the port.
portThe port to add.
callback(Optional) provide a function which will be called asynchronously when new data arrives on this port. You can add more functions by using the port directly using base::PortInterface::getNewDataOnPort().

Definition at line 547 of file TaskContext.hpp.

References RTT::base::PortInterface::setName().

Add an Event triggering Port to the interface of this task and add a Service with the same name of the port.

Parameters:
portThe port to add.
callback(Optional) provide a function which will be called asynchronously when new data arrives on this port. You can add more functions by using the port directly using base::PortInterface::getNewDataOnPort().

Definition at line 560 of file TaskContext.hpp.

template<class Signature >
Operation<Signature>& RTT::TaskContext::addOperation ( Operation< Signature > &  op) [inline]

Add an operation object to the interface.

This version of addOperation exports an Operation object to the public interface of this component.

Parameters:
opThe operation object to add.
Returns:
true if it could be added.

Definition at line 347 of file TaskContext.hpp.

template<class Func , class Service >
Operation< typename internal::GetSignature<Func>::Signature >& RTT::TaskContext::addOperation ( const std::string  name,
Func  func,
Service serv,
ExecutionThread  et = ClientThread 
) [inline]

Adds a C++ function as an operation.

See also:
Service::addOperation

Definition at line 358 of file TaskContext.hpp.

template<class Signature >
Operation< Signature >& RTT::TaskContext::addOperation ( const std::string  name,
Signature *  func,
ExecutionThread  et = ClientThread 
) [inline]

Adds a C function as an operation.

See also:
Service::addOperation

Definition at line 369 of file TaskContext.hpp.

bool RTT::TaskContext::addPeer ( TaskContext peer,
std::string  alias = "" 
) [virtual]

Add a one-way connection from this task to a peer task.

Parameters:
peerThe peer to add.
aliasAn optional alias (another name) for the peer. defaults to peer->getName()

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 252 of file TaskContext.cpp.

References getName().

Referenced by connectPeers().

base::PortInterface& RTT::TaskContext::addPort ( const std::string &  name,
base::PortInterface port 
) [inline]

Name and add a Port to the interface of this task and add a Service with the same name of the port.

Parameters:
nameThe name to give to the port.
portThe port to add.

Definition at line 523 of file TaskContext.hpp.

References RTT::base::PortInterface::setName().

Add a Port to the interface of this task and add a Service with the same name of the port.

Parameters:
portThe port to add.

Definition at line 533 of file TaskContext.hpp.

template<class T >
Property<T>& RTT::TaskContext::addProperty ( const std::string &  name,
T &  attr 
) [inline]

Adds a variable of any type as a property to the attribute interface.

A Property is created which causes contents of the property always to be in sync with the contents of attr.

Parameters:
nameThe name of this property
attrThe variable that will be aliased.
Returns:
the Property object by reference, which you can further query or document.

Definition at line 479 of file TaskContext.hpp.

Add an base::PropertyBase as a property.

Returns:
false if a property with the same name already exists.

Definition at line 487 of file TaskContext.hpp.

bool RTT::TaskCore::breakUpdateHook ( ) [protected, virtual, inherited]

Implement this function if your code might block for long times inside the updateHook() function.

Insert in this hook the code to wake up that code or signal it otherwise that updateHook() is requested to return (for example by setting a flag). The method returns false by default.

Returns:
true if well received and updateHook() will soon return. False otherwise.

Definition at line 311 of file TaskCore.cpp.

Referenced by RTT::ExecutionEngine::breakLoop().

bool RTT::TaskCore::cleanup ( ) [virtual, inherited]

This method instructs a stopped component to enter the pre-operational state again.

It calls cleanupHook().

Returns:
true if the component was in the Stopped state.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 126 of file TaskCore.cpp.

References RTT::base::TaskCore::cleanupHook(), RTT::base::TaskCore::exception(), RTT::base::TaskCore::PreOperational, and RTT::base::TaskCore::Stopped.

void RTT::TaskCore::cleanupHook ( ) [protected, virtual, inherited]

Implement this method such that it contains the code which will be executed when cleanup() is called.

The default implementation is an empty function.

Definition at line 244 of file TaskCore.cpp.

Referenced by RTT::base::TaskCore::cleanup(), and RTT::base::TaskCore::exception().

void RTT::TaskContext::clear ( ) [virtual]
bool RTT::TaskCore::configure ( ) [virtual, inherited]

This method instructs the component to (re-)read configuration data and try to enter the Stopped state.

This can only succeed if the component is not running and configureHook() returns true.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 103 of file TaskCore.cpp.

References RTT::base::TaskCore::configureHook(), RTT::base::TaskCore::exception(), RTT::base::TaskCore::PreOperational, and RTT::base::TaskCore::Stopped.

bool RTT::TaskCore::configureHook ( ) [protected, virtual, inherited]

Implement this method such that it contains the code which will be executed when configure() is called.

The default implementation is an empty function which returns true.

Return values:
trueto indicate that configuration succeeded and the Stopped state may be entered.
falseto indicate that configuration failed and the Preoperational state is entered.

Definition at line 292 of file TaskCore.cpp.

Referenced by RTT::base::TaskCore::configure().

void RTT::TaskContext::disconnect ( ) [virtual]

Disconnect this TaskContext from it's peers and ports.

All its Data Flow Ports are disconnected as well. This method invokes removePeer() as well on the peers listed in this->getPeerList().

Definition at line 292 of file TaskContext.cpp.

References getName(), RTT::DataFlowInterface::getPorts(), and ports().

void RTT::TaskCore::error ( ) [virtual, inherited]

Call this method in a Running state to indicate a run-time error condition.

errorHook() will be called instead of updateHook(). If the error condition is solved, call recover().

Definition at line 151 of file TaskCore.cpp.

References RTT::base::TaskCore::Running, and RTT::base::TaskCore::RunTimeError.

void RTT::TaskCore::errorHook ( ) [protected, virtual, inherited]

Implement this method to contain code that must be executed in the RunTimeError state, instead of updateHook().

This allows you to specify the behaviour in an erroneous component. errorHook() is called as long as the component is not recover()'ed. After recover()'ed, the updateHook() is called again.

Definition at line 301 of file TaskCore.cpp.

void RTT::TaskCore::exception ( ) [protected, virtual, inherited]

Call this method to indicate a run-time exception happend.

First the TaskState is set to Exception. Next, if the taskstate was >= Running, stopHook() is called. Next, if the taskstate was >= Stopped, cleanupHook() is called. Finally, exceptionHook() is called. If any exception happens in exceptionHook(), fatal() is called.

Definition at line 158 of file TaskCore.cpp.

References RTT::base::TaskCore::cleanupHook(), RTT::base::TaskCore::Exception, RTT::base::TaskCore::exceptionHook(), RTT::base::TaskCore::fatal(), RTT::base::TaskCore::PreOperational, RTT::base::TaskCore::Running, RTT::base::TaskCore::stopHook(), and RTT::base::TaskCore::Stopped.

Referenced by RTT::base::TaskCore::cleanup(), RTT::base::TaskCore::configure(), RTT::ExecutionEngine::setExceptionTask(), RTT::base::TaskCore::start(), and RTT::base::TaskCore::stop().

void RTT::TaskCore::exceptionHook ( ) [protected, virtual, inherited]

Implement this method to contain code that must be executed when transitioning to the Exception state.

This allows you to specify the last actions in an erroneous component, after stopHook() and cleanupHook() were called.

See also:
recover() to leave the Exception state.

Definition at line 316 of file TaskCore.cpp.

Referenced by RTT::base::TaskCore::exception().

void RTT::TaskCore::fatal ( ) [protected, virtual, inherited]

Call this method from any place to indicate that this component encountered a fatal error.

It calls no hooks, the ExecutionEngine is stopped and the component waits destruction.

Definition at line 145 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::TaskCore::FatalError, RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::stop().

Referenced by RTT::base::TaskCore::exception().

Forces the current activity to become new_act, even if this TaskContext is still running.

This can be used to bypass the isRunning() check regular setActivity() does.

Definition at line 362 of file TaskContext.cpp.

References RTT::base::TaskCore::engine(), and RTT::base::ActivityInterface::stop().

Referenced by RTT::corba::TaskContextProxy::TaskContextProxy().

Get a pointer to the activity running this component.

Returns:
Our activity.

Definition at line 373 of file TaskContext.cpp.

References RTT::base::TaskCore::engine(), and RTT::base::RunnableInterface::getActivity().

template<typename T >
T* RTT::TaskContext::getActivity ( ) [inline]

Get a pointer to the activity running this component.

Unlike the non-template version, it converts it to the activity type provided.

Example usage in a startHook(): RTT::extras::FileDescriptorActivity* fd_activity = getActivity<RTT::extras::FileDescriptorActivity>(); if (fd_activity) { // do specific setup for FDActivity }

Returns:
Our activity if it is of type T, NULL otherwise.

Definition at line 173 of file TaskContext.hpp.

References getActivity().

Referenced by getActivity().

base::AttributeBase* RTT::TaskContext::getAttribute ( const std::string &  name) const [inline]

Adds a variable of any type as read/write attribute to the attribute interface.

An Alias is created which causes contents of the attr variable always to be in sync with the contents of the attribute object in the interface.

Parameters:
nameThe name of this attribute
attrThe variable that will be aliased.

Definition at line 450 of file TaskContext.hpp.

unsigned RTT::TaskCore::getCpuAffinity ( ) const [virtual, inherited]

Get the configured cpu affinity of this component.

See also:
ActivityInterface::getCpuAffinity()

Definition at line 282 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::getCpuAffinity().

OperationInterfacePart* RTT::TaskContext::getOperation ( std::string  name) [inline]

Get a previously added operation for use in a C++ OperationCaller object.

Store the result of this function in a OperationCaller<Signature> object.

Parameters:
nameThe name of the operation to retrieve.
Returns:
true if it could be found, false otherwise.

Definition at line 383 of file TaskContext.hpp.

TaskContext * RTT::TaskContext::getPeer ( const std::string &  peer_name) const [virtual]

Get a pointer to a peer of this task.

Returns:
null if no such peer.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 336 of file TaskContext.cpp.

References hasPeer().

Seconds RTT::TaskCore::getPeriod ( ) const [virtual, inherited]

Get the configured execution period of this component.

Note that this value only is used when the component isActive() or isRunning().

Return values:
0.0if the component is non-periodic (event based).
anegative number when the component is not executable.
apositive value when the component is periodic. The period is expressed in seconds.
Todo:
: add a bool setPeriod(double) function to allow changing the period at run-time.

Definition at line 272 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::getPeriod().

base::PortInterface* RTT::TaskContext::getPort ( const std::string &  name) const [inline]

Get a port of this Component.

Parameters:
nameThe port name
Returns:
a pointer to a port or null if it does not exist.

Definition at line 569 of file TaskContext.hpp.

base::PropertyBase* RTT::TaskContext::getProperty ( const std::string &  name) const [inline]

Get a Property with name name.

Parameters:
nameThe name of the property to search for.
Returns:
The Property with this name, zero if it does not exist

Definition at line 498 of file TaskContext.hpp.

template<class ServiceType >
boost::shared_ptr<ServiceType> RTT::TaskContext::getProvider ( const std::string &  name) [inline]

Use this method to be able to make OperationCaller calls to services provided by this component.

In case the service does not exist in this component, it tries to load the service using the plugin::PluginLoader class. If all fails, a null pointer is returned.

For example: getProvider<Scripting>("scripting")->loadPrograms("file.ops");

Parameters:
nameThe name of the service to get, must have been added with addService.
ServiceTypethe ServiceRequester type to use. Must have a constructor that takes TaskContext* as argument.
Returns:
a shared ServiceRequester object which allows to call the operations provided by service name.

Definition at line 309 of file TaskContext.hpp.

TaskCore::TaskState RTT::TaskCore::getTargetState ( ) const [virtual, inherited]

Returns the state this TaskCore is going to, or in case no transition is taking place, returns getTaskState().

For example, before start(), this function returns Stopped. During startHook(), it returns Running and after start() it also returns Running.

If getTaskState() != getTargetState, a transition is taking place.

See also:
getTaskState()

Definition at line 85 of file TaskCore.cpp.

TaskCore::TaskState RTT::TaskCore::getTaskState ( ) const [virtual, inherited]

Returns the current state of the TaskCore.

For example, before start(), this function returns Stopped. During startHook() it returns Stopped, and after start() it returns Running.

See also:
getTargetState()

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 81 of file TaskCore.cpp.

bool RTT::TaskCore::inFatalError ( ) const [virtual, inherited]

Inspect if the component is in the FatalError state.

There is no possibility to recover from this state. You need to destroy and recreate your component.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 255 of file TaskCore.cpp.

References RTT::base::TaskCore::FatalError.

bool RTT::TaskCore::isActive ( ) const [virtual, inherited]

Inspect if the component's ExecutionEngine is processing requests.

Normally this is always the case, but user code could stop the ExecutionEngine manually.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 267 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::isActive().

Referenced by RTT::base::TaskCore::activate().

bool RTT::TaskCore::isConfigured ( ) const [virtual, inherited]

Inspect if the component is configured, i.e.

in the Stopped, Active or Running state.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 251 of file TaskCore.cpp.

References RTT::base::TaskCore::Stopped.

bool RTT::TaskCore::isRunning ( ) const [virtual, inherited]

Inspect if the component is in the Running or RunTimeError state.

As RunTimeError is a substate of Running, this method also returns true when the component is in one of these states. See inRunTimeError() or testing the run-time error state.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 247 of file TaskCore.cpp.

References RTT::base::TaskCore::Running.

Referenced by setActivity(), start(), and stop().

bool RTT::TaskContext::loadService ( const std::string &  service_name)

Use this method to load a service known to RTT into this component.

Parameters:
service_nameThe name with which the service is registered by in the PluginLoader.
Returns:
true if the service was present already or could be loaded.

Definition at line 233 of file TaskContext.cpp.

References RTT::plugin::PluginLoader::Instance(), and provides().

Service::shared_ptr RTT::TaskContext::provides ( ) [inline]
Service::shared_ptr RTT::TaskContext::provides ( const std::string &  service_name) [inline]

Returns a sub-Service which resorts under this Service.

Parameters:
service_nameThe name of the sub-service.

Definition at line 275 of file TaskContext.hpp.

bool RTT::TaskContext::ready ( ) [virtual]

Checks the validity of this TaskContext.

When this method returns false, the TaskContext should not be used and various methods may throw exceptions. Use this in case the TaskContext could be a remote object. Will always return true when this TaskContext is local.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 385 of file TaskContext.cpp.

bool RTT::TaskCore::recover ( ) [virtual, inherited]

Call this method in a RunTimeError or Exception state to indicate that the run-time error conditions are gone and nominal operation is resumed.

Makes transition to Running or PreOperational, depending on the state it was in.

Returns:
false if not applicable in the current state.

Definition at line 180 of file TaskCore.cpp.

References RTT::base::TaskCore::Exception, RTT::base::TaskCore::Running, and RTT::base::TaskCore::RunTimeError.

Sets the activity of this TaskContext.

The activity is owned by the TaskContext and you should not hold a pointer to it after this call. Use getActivity() lateron to retrieve a safe pointer to it.

Parameters:
new_actThe new activity for this TaskContext, which becomes owned by this TaskContext, in case this method returns true.
Returns:
false if this->isRunning(). You can not change the activity of a TaskContext once it is running. In that case, new_act is not destroyed.
Note:
This function may not be called from the current ExecutionEngine thread (OwnThread), another thread (ClientThread) must call this function.

Definition at line 343 of file TaskContext.cpp.

References RTT::base::TaskCore::engine(), RTT::base::TaskCore::isRunning(), RTT::base::ActivityInterface::run(), and RTT::base::ActivityInterface::stop().

Referenced by RTT::corba::TaskContextProxy::TaskContextProxy().

bool RTT::TaskCore::setCpuAffinity ( unsigned  cpu) [virtual, inherited]

Sets the cpu affinity of this component.

Returns:
false if not allowed by the component's activity.
See also:
ActivityInterface::setCpuAffinity()

Definition at line 287 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::setCpuAffinity().

void RTT::TaskCore::setExecutionEngine ( ExecutionEngine engine) [inherited]

Use this method to re-set the execution engine of this task core.

Parameters:
engineThe new execution engine which will execute this TaskCore or null if a new execution engine must be created (the old is deleted in that case).
Postcondition:
The TaskCore is being run by engine or a new execution engine.

Definition at line 323 of file TaskCore.cpp.

References RTT::ExecutionEngine::addChild(), RTT::base::TaskCore::ee, RTT::base::TaskCore::engine(), RTT::ExecutionEngine::getParent(), and RTT::ExecutionEngine::removeChild().

bool RTT::TaskCore::setPeriod ( Seconds  s) [virtual, inherited]

Sets the period of this component.

You may call this at any time, it is simply forwarded to the component's activity object.

Returns:
false if not allowed by the component's activity.
See also:
ActivityInterface::setPeriod()

Definition at line 277 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::setPeriod().

bool RTT::TaskContext::start ( ) [virtual]

This method starts the execution of the updateHook() with each trigger or period.

This function calls the user function startHook(), which must return true in order to allow this component to run.

Return values:
false
  • if startHook() returned false
  • if the component was not Stopped
trueif the Running state was entered.

Reimplemented from RTT::base::TaskCore.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 398 of file TaskContext.cpp.

References RTT::base::TaskCore::isRunning(), and ports().

bool RTT::TaskCore::startHook ( ) [protected, virtual, inherited]

Implement this method such that it contains the code which will be executed when start() is called.

The default implementation is an empty function which returns true.

Return values:
trueto indicate that the component may run and the Running state may be entered.
falseto indicate that the component may not run and the Stopped state is entered.

Definition at line 296 of file TaskCore.cpp.

Referenced by RTT::base::TaskCore::start().

bool RTT::TaskContext::stop ( ) [virtual]

This method stops the execution of updateHook() of this component.

You can override this method to do something else or in addition. This function calls stopHook() as well.

Returns:
false if the component was not Running or not Active.

Reimplemented from RTT::base::TaskCore.

Reimplemented in RTT::corba::TaskContextProxy.

Definition at line 408 of file TaskContext.cpp.

References RTT::base::TaskCore::isRunning(), ports(), and RTT::base::TaskCore::stop().

void RTT::TaskCore::stopHook ( ) [protected, virtual, inherited]

Implement this method such that it contains the code which will be executed when stop() is called.

The default implementation is an empty function.

Definition at line 319 of file TaskCore.cpp.

Referenced by RTT::base::TaskCore::exception(), and RTT::base::TaskCore::stop().

bool RTT::TaskCore::trigger ( ) [virtual, inherited]

Invoke this method to trigger the thread of this TaskContext to execute its ExecutionEngine and the update() method.

Return values:
falseif this->engine()->getActivity()->trigger() == false
trueotherwise.

Definition at line 96 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::RunnableInterface::getActivity(), and RTT::base::ActivityInterface::trigger().

Referenced by RTT::base::TaskCore::start().

bool RTT::TaskCore::update ( ) [virtual, inherited]

Invoke this method to execute the ExecutionEngine and the update() method.

Return values:
falseif this->engine()->getActivity()->execute() == false
trueotherwise.

Definition at line 89 of file TaskCore.cpp.

References RTT::base::TaskCore::engine(), RTT::base::ActivityInterface::execute(), and RTT::base::RunnableInterface::getActivity().

void RTT::TaskCore::updateHook ( ) [protected, virtual, inherited]

Function where the user must insert his 'application' code.

When the ExecutionEngine's Activity is a periodic, this function is called by the ExecutionEngine in each periodic step after all messages are processed. When it is executed by a non periodic activity, this function is called after a message is received and executed. It should not loop forever, since no commands or events are processed when this function executes. The default implementation is an empty function.

Definition at line 307 of file TaskCore.cpp.


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