| RTT::ActionInterface | Based on the software pattern 'action', this interface allows execution of action objects |
| RTT::Corba::ActionProxy | This class manages the access of remote Action Corba Servers |
| RTT::Activity | An Activity is an object that represents a thread |
| RTT::ActivityInterface | Interface to start/stop and query a Activity |
| RTT::AdaptAssignableDataSource< TResult > | Try to adapt a DataSourceBase to an AssignableDataSource< by value > |
| RTT::AdaptAssignableDataSource< TResult & > | Try to adapt a DataSourceBase to an AssignableDataSource< by reference > |
| RTT::AdaptDataSource< TResult > | Try to adapt a DataSourceBase to a DataSource< by value > |
| RTT::AdaptDataSource< const TResult & > | Try to adapt a DataSourceBase to a DataSource< by const reference > Allows all conversions |
| RTT::AdaptDataSource< const TResult > | Try to adapt a DataSourceBase to a DataSource< by const value > |
| RTT::AdaptDataSource< TResult & > | Try to adapt a DataSourceBase to a DataSource< by ref > |
| RTT::Alias< T > | This class is the most basic Attribute implementation (only suitable for reading a DataSource), does not allow any assignment, just stores a DataSource<T>, and returns it |
| RTT::AnalogInInterface | An interface for reading analog input, like for addressing a whole subdevice in comedi |
| RTT::AnalogInput | A class representing an analog input channel |
| RTT::AnalogOutInterface | An interface for writing analog output, like for addressing a whole subdevice in comedi |
| RTT::AnalogOutput | A class representing an analog output channel |
| RTT::AnyConversion< Type > | This class converts a given application-specific type to a CORBA::Any object and vice versa |
| RTT::Corba::AnyDataSource | A DataSource which holds an any value and returns it in its get() method |
| RTT::Corba::ApplicationServer | A class which an provides ORB to the application process |
| RTT::detail::ArgMember< F > | A complexer variant of UnMember: Convert a member function type to a function type which contains the member as first argument |
| RTT::ArgumentDescription | Description of one Argument of a Command |
| RTT::detail::ArgumentsParser | This is a parser that you construct to parse a set of arguments |
| RTT::AssignableDataSource< T > | A DataSource which has set() methods |
| RTT::detail::AssignableDataSourceAdaptor< From, To > | AssignableDataSourceAdaptor allows a conversion from an AssignableDataSource<T> to DataSource<[const] T [&]> which will return the result of the AssignableDataSource<T>::set() method in its get() (thus a reference to a heaped value) |
| RTT::detail::AssignableDataSourceAdaptor< From, const From & > | AssignableDataSourceAdaptor allows a conversion from an AssignableDataSource<T> to DataSource<T> which will return the result of the AssignableDataSource<T>::rvalue() method in its get() (thus a reference to a heaped value) |
| RTT::detail::AssignableDataSourceAdaptor< To const &, To > | AssignableDataSourceAdaptor allows a conversion from an AssignableDataSource<const& T> to AssignableDataSource<T> |
| RTT::detail::AssignCommand< T, S > | This is a command that will assign the value of an expression to another at runtime |
| RTT::detail::AssignContainerCommand< T, APred, S > | Assign the contents of one variable-size container to another |
| RTT::detail::AssignIndexCommand< T, Index, SetType, Pred > | This command assigns an element of a container to a given value |
| RTT::detail::AStore< T > | Store a bound argument which may be a reference, const reference or any other type |
| RTT::AsynchCommandDecorator | Based on the software patterns 'command' and 'decorator', this interface represents a wrapper around a given command, which decorates that command as an asynchronous command |
| RTT::OS::AtomicInt | C++ abstraction of atomic integer operations |
| RTT::AtomicQueue< T, ReadPolicy, WritePolicy > | A lock-free queue implementation to enqueue or dequeue a pointer of type T |
| RTT::Attribute< T > | An Attribute has a name and contains data which can be set and get |
| RTT::AttributeBase | An attribute is a minimalistic, named placeholder for data |
| RTT::AttributeRepository | A class for keeping track of Attribute, Constant and Property objects of a TaskContext |
| RTT::AxisInterface | The AxisInterface represents an axis from a control point of view |
| RTT::bad_assignment | This exception is thrown if the target and source type of an assignment of a DataSource with a DataSourceBase differ |
| RTT::rt_std::basic_iostreams | An IO stream based on strings |
| RTT::rt_std::basic_istreams | An basic_istream is a stream which can be read |
| RTT::rt_std::basic_ostreams | An basic_ostreams is a stream which can be written to |
| RTT::rt_std::basic_streams | This is a stream class for use in limited environments |
| RTT::BinaryDataSource< function > | A generic binary composite DataSource |
| RTT::detail::BinaryOperator< function > | An operator which reads a two DataSources and returns a modified result |
| RTT::detail::BindStorage< ToBind > | A helper-class for the Command implementation which stores the command and condition function objects |
| RTT::detail::BindStorageImpl< 0, ToBind > | When no arguments are to be stored, the implementation stores the function in a boost::function object |
| RTT::detail::BindStorageImpl< 1, ToBind > | Stores a pointer to a function and its arguments |
| RTT::BlockingEventProcessor | The Blocking EventProcessor, extended with a blocking implementation, waiting for one Event to complete in its loop() |
| RTT::BlockingPolicy | Use this policy to indicate that you do want to block on an empty or full buffer, queue, fifo, |
| RTT::Buffer< T, ReadPolicy, WritePolicy > | This object represents the default queue implementation used by Orocos objects |
| RTT::BufferBase | Any Buffer has a capacity, size and can be empty or full |
| RTT::BufferConnection< T > | A local connection with a Buffer, which is used to connect multiple Ports to that Buffer |
| RTT::BufferDataSource< T > | A DataSource which provides read-only access to the next value to be read from the buffer, without removing that value from the buffer |
| RTT::BufferInterface< T > | A Buffer is an object which is used to store (Push) and retrieve (Pop) values from |
| RTT::BufferLocked< T, ReadPolicy, WritePolicy > | Implements a very simple blocking threadsafe buffer, using mutexes (locks) |
| RTT::BufferLockFree< T, ReadPolicy, WritePolicy > | A Lock-free buffer implementation to read and write data of type T in a FIFO way |
| RTT::BufferPort< T > | A Port to a read-write Buffer |
| RTT::detail::BuildType< T > | A helper class to build a value of type T |
| RTT::CalibrationInterface | A class which will calibrate a sensor |
| RTT::CallbackInterface | Generic callback interface |
| RTT::OS::CleanupFunction | Use this to register a global cleanup function to the StartStopManager |
| RTT::CleanupHandle | A connection Handle of a (connected) slot which disconnects and cleans up (free all resources) a slot from a signal in its destructor |
| RTT::Command< CommandT > | A Command is a function which can be sent to a task for execution and be queried for its execution status |
| RTT::detail::CommandBase< F > | The base class for all command implementations |
| RTT::CommandC | A user friendly Command to a TaskContext |
| RTT::CommandComposite | Based on the software pattern 'composite', this class RTT_API allows composing command objects into one command object |
| RTT::CommandCounter | This command increments a counter when executed |
| RTT::CommandDataSource | A Command which evaluates a DataSourceBase and always returns true |
| RTT::CommandDataSourceBool | A Command which evaluates a DataSource<bool> and returns the result of get() |
| RTT::CommandDispatch | Dispatch a CommandInterface to a CommandProcessor |
| RTT::CommandDS< CommandT > | A Command storage container |
| RTT::CommandExecFunction | A command which queues (dispatches) a FunctionFraph for execution in a ProgramProcessor |
| RTT::detail::CommandFunction | A functor with the CommandInterface, for the case where the functor is a bool(void) |
| RTT::CommandFunctor< F > | A Command which can be bound to a function using boost::bind |
| RTT::detail::CommandFunctor< SignatureT, FunctorT > | A functor with the CommandInterface |
| RTT::CommandFunctor< boost::function< bool(void) > > | Specialisation of CommandFunctor |
| RTT::CommandIllegal | A Command indicating that an error was encountered somewhere, most likely during the construction of another command |
| RTT::CommandNOP | The empty command |
| RTT::detail::CommandParser | This class parses commands |
| RTT::CommandProcessor | This class implements an Orocos command processor |
| RTT::Corba::CommandProxy | This class manages the access of remote Command Corba Servers |
| RTT::CommandRepository | A command repository stores a number of commands from a Task which can be used by other tasks or from scripts |
| RTT::CommandString | This command displays a string when executed |
| RTT::detail::CommonParser | This class contains some very common parser definitions |
| RTT::CompletionProcessor | An activity which executes asynchronous (defered) handlers of Events |
| RTT::ConditionBinaryCompositeAND | Compose an 'AND' function of two Conditions |
| RTT::ConditionBoolDataSource | A Condition which holds a boolean DataSource |
| RTT::ConditionBoolProperty | ConditionBoolProperty is a Condition which reads out a Property<bool> |
| RTT::ConditionCompare< T, compare_op > | A general compare condition |
| RTT::ConditionDSDuration | A conditional that evaluates true after a certain time (in seconds) has passed, given by a DataSource |
| RTT::ConditionDuration | A conditional that evaluates true after a certain time has passed |
| RTT::ConditionExecFunction | A condition which checks if a CommandExecFunction is done or not |
| RTT::ConditionExpire | A conditional that evaluates true until a certain time has elapsed since construction or the last reset() |
| RTT::ConditionFalse | A conditional that evaluates false |
| RTT::detail::ConditionFunction | A functor with the ConditionInterface, for the case where the functor is a bool(void) |
| RTT::detail::ConditionFunctor< SignatureT, FunctorT > | A functor with the ConditionInterface |
| RTT::ConditionInterface | This interface represents the concept of a condition which can be evaluated and return true or false |
| RTT::ConditionInvert | A conditional that evaluates to the inverse of another Condition |
| RTT::ConditionOnce | A conditional that evaluates the first time true and afterwards always false (or vice versa) |
| RTT::detail::ConditionParser | This is a class containing a parse function for conditions |
| RTT::ConditionTrue | A conditional that evaluates true |
| RTT::ConfigurationInterface | Generic run-time class configuration interface |
| RTT::Configurator | A class which configures other objects in small steps spread in time |
| RTT::ConnectionC | A user friendly callback connection to an event of a TaskContext |
| RTT::ConnectionFactory< T > | Builds Connections (buffers or data objects) between the ports of tasks |
| RTT::ConnectionInterface | An Object which manages and maintains a communication connection between Ports |
| RTT::ConnectionTypes | Enumerates all the types of connections supported by this factory |
| RTT::Constant< T > | As opposed to a Attribute, a Constant can not be assigned to a new value after creation |
| RTT::ConstantDataSource< T > | A DataSource which holds a constant value and returns it in its get() method |
| RTT::Corba::ControlTaskProxy | This class manages the access of remote TaskContext Corba Servers and a Corba Object Request Broker (Orb) which connects to these servers |
| RTT::Corba::ControlTaskServer | This class manages the creation of TaskContext Corba Servers and a Corba Object Request Broker (Orb) which executes the servers |
| RTT::Corba::CORBAAssignableExpression< T > | Mirrors a remote assignable expression |
| RTT::Corba::CorbaBuffer< T > | A Buffer servant using a Corba Event Channel |
| RTT::Corba::CorbaBufferProxy< T > | A Buffer Proxy to a remote Orocos Buffer connection |
| RTT::Corba::CorbaCommandFactory | This class mirrors a Corba Command Factory as a plain C++ factory |
| RTT::Corba::CorbaDataObject< T > | A class which serves local data and provides it to the Corba Event Service as well |
| RTT::Corba::CorbaDataObjectProxy< T > | A class which provides access to remote Corba Data |
| RTT::Corba::CORBAExpression< T > | Mirrors a remote expression object |
| RTT::Corba::CORBAExpression< void > | Specialisation for void DataSources |
| RTT::Corba::CorbaMethodFactory | A local factory for creating remote Corba methods |
| RTT::Corba::CorbaPort | A port used by ControlTaskProxy objects to connect a corba data or buffer channel as an Orocos Port |
| RTT::Corba::CorbaService | A service that is installed in each component that runs as a CORBA server |
| RTT::detail::CorbaTemplateProtocol< T > | For each transportable type T, specify the conversion functions |
| RTT::CPFMarshaller< std::ostream > | A class for marshalling a property or propertybag into a component property description, following the CORBA 3 standard |
| RTT::detail::DataCallParser | This parser parses a call of the form "a.b( arg1, arg2, ..., argN )" |
| RTT::DataConnection< T > | A local connection with a DataObject, which is used to connect multiple Ports to that DataObject |
| RTT::DataFlowInterface | The Interface of a TaskContext which exposes its data-flow ports |
| RTT::DataObject< T > | A class which provides unchecked access to one typed element of data |
| RTT::DataObjectInterface< T > | A DataObjectInterface extends the AssignableDataSource with implementations of multi-threaded read/write solutions |
| RTT::DataObjectLocked< T > | A class which provides locked/protected access to one typed element of data |
| RTT::DataObjectLockFree< T > | This DataObject is a Lock-Free implementation, such that reads and writes can happen concurrently without priority inversions |
| RTT::DataObjectPriorityGet< T > | A DataObject which allows only the high priority thread to Get(), and both low and high priorities to Set() |
| RTT::DataObjectPrioritySet< T > | A DataObject which allows only the high priority thread to Set(), and both low and high priorities to Get() |
| RTT::DataPort< T > | A data port which can be used as a reader and as a writer |
| RTT::DataSource< T > | DataSource is a base class representing a generic way to read data of type T |
| RTT::detail::DataSourceAdaptor< From, To > | Adapt parser DataSource storage type to user type |
| RTT::detail::DataSourceAdaptor< const TFrom &, const TFrom > | Specialises DataSourceAdaptor< const int&, const int > |
| RTT::detail::DataSourceAdaptor< const TFrom, const TFrom & > | DataSourceAdaptor specialisation to not return a reference to a stack based variable ( case (4bis) ) |
| RTT::detail::DataSourceAdaptor< TFrom &, TFrom & > | Adapt from non-const reference-type to non-const reference-type, yielding an AssignableDataSource, since references are always assignable |
| RTT::detail::DataSourceAdaptor< TFrom &, TFrom > | Adapt from non-const reference-type to value-type, yielding an AssignableDataSource, since references are always assignable |
| RTT::detail::DataSourceAdaptor< TFrom, const TFrom & > | DataSourceAdaptor specialisation to not return a const reference to a stack based variable ( case (4) ) |
| RTT::detail::DataSourceArgsCommand< CommandT, CommandF > | A Command which dispatches locally |
| RTT::detail::DataSourceArgsEvent< SignatureT, FunctorT > | A event which gets its arguments from a data source and is an action object |
| RTT::detail::DataSourceArgsMethod< SignatureT, FunctorT > | A method which gets its arguments from a data source and is a datasource itself |
| RTT::detail::DataSourceArgStorage< A & > | |
| RTT::DataSourceBase | The base class for all DataSource's |
| RTT::DataSourceCommand | A class that wraps a Command in a DataSource<bool> interface |
| RTT::DataSourceCondition | A class that wraps a Condition in a DataSource<bool> interface |
| RTT::detail::DataSourceResultStorage< R & > | |
| RTT::detail::DataSourceStorage< DataType > | A helper-class for the Command implementation which stores the command and condition function objects |
| RTT::detail::DataSourceStorageImpl< 0, DataType > | When no arguments are to be stored |
| RTT::detail::DataSourceStorageImpl< 1, DataType > | Stores one data source |
| RTT::DataSourceTime | A DataSource which returns the time elapsed since the last reset in Seconds |
| RTT::detail::DataSourceTypeInfo< T > | Every DataSource of type T has a type info class which it can ask type information |
| RTT::detail::DataSourceTypeInfo< const T & > | These specialisations only serve to find out if a type T is a pointer, or reference, or |
| RTT::detail::DataSourceTypeInfo< UnknownType > | This class offers the default implementation of type information for an unknown type |
| RTT::detail::DataSourceTypeInfo< void > | (void) is a special case |
| RTT::DemarshallConfiguration< InputStream, HeaderDemarshaller, BodyDemarshaller > | Contains the required classes for a full demarshalling operation |
| RTT::Demarshaller | An interface for extracting properties from a format |
| RTT::DigitalInInterface | A class representing a Digital Input device from which a maximum of 32 bits can be read at once |
| RTT::DigitalInput | A class representing a switch which can be on or off |
| RTT::DigitalOutInterface | A class representing a Digital Output device which can read or write a maximum of 32 bits at once |
| RTT::DigitalOutput | A DigitalOut represents any on/off output |
| RTT::DispatchAction | An action which invokes a dispatch command in execute() |
| RTT::DispatchInterface | Dispatch a CommandInterface to a CommandProcessor and track its status |
| RTT::DLib::DLibCommand< CommandT, ProtocolT > | A Command which is dispatched using the 'Distribution Library' to a CommandProcessor |
| RTT::DLib::DLibCommandImpl< CommandT, ProtocolT > | The DistributionLibrary (DL) Command wrapper class |
| RTT::detail::DotOp | The Dot Operator allows access to members of composite types, such as in frame.pos.x |
| RTT::detail::DotOperator< function > | Dot : ' |
| RTT::DriveInterface | A Drive Object controls a single axis |
| RTT::EdgeCondition | This class represents a conditional branch in a program tree |
| RTT::EmptyHeaderMarshaller< o_stream > | A Dummy Empty Header Marshaller |
| RTT::EmptyMarshaller | A Dummy Empty Marshaller |
| RTT::EmptyTypeInfo | Empty implementation of TypeInfo interface |
| RTT::EncoderInterface | The most generic interface to a position/turn counter, for encoding positions |
| RTT::eol_skip_functor | Due to a bug in MSVC 2005, the operator() ends up with a null reference of the skipeol member Tried several workarounds, could not find one, except turning off optimization for this function |
| RTT::EvalCommand | Evaluates a DataSource<bool> in a command |
| RTT::EvalCommandResult | The result of a command which evaluates a boolean DataSource |
| RTT::Event< SignatureT > | The Orocos Event is a thread-safe publish-subscribe implementation and provides synchronous and asynchronous callback handling |
| RTT::detail::EventBase< Signature > | The base class of Event implementations |
| RTT::EventC | A user friendly event of a TaskContext |
| RTT::detail::EventCallBack | Class used by ConnectionC to 'wrap' user functions to a form usable by the EventService, namely a void(void) function with a list of AssignableDataSources which store the event arguments |
| RTT::detail::EventCatcherImpl< 0, SignalType, ContainerType > | Catch the event, dispatch later to F |
| RTT::EventDrivenActivity | An Event-driven ActivityInterface implementation |
| RTT::detail::EventHookBase | Create end-user event handles |
| RTT::detail::EventHookGenerator< EventT > | Generate EventHook depending on number of arguments |
| RTT::EventProcessor | An Asynchronous Event Processor, which catches events and executes the asynchronous callbacks in its RunnableInterface::step() |
| RTT::EventService | The EventService represents the event interface |
| RTT::ExecutionAccess | The ExecutionAccess provides access to programs and state machines loaded in the execution engine |
| RTT::ExecutionEngine | An execution engine serialises (executes one after the other) the execution of all commands, programs, state machines and incomming events for a task |
| RTT::detail::ExpressionParser | How we parse: this parser works like a stack-based RPN calculator |
| RTT::Corba::ExpressionProxy | This class manages the access of remote Expression Corba Servers |
| RTT::Corba::ExpressionServer | This class manages the access of local Expression Corba Servants and Servers |
| RTT::detail::fatal_semantic_parse_exception | A Fatal Semantic parse exception means the parser knows that the parsing failed dramatically and should not be passed to another parser |
| RTT::detail::fatal_syntactic_parse_exception | A Fatal Syntactic parse exception means the parser knows the input is plain wrong and no further attemts should be made to parse it |
| RTT::file_parse_exception | This is an exception class that keeps a parse_exception pointer along with the location in the file and the file where it occurred |
| RTT::PropertyBag::FindProp | A function object for finding a Property by name |
| RTT::PropertySequence< T >::FindProp | A function object for finding a Property by name |
| RTT::FixedSizeMemoryPool< T > | A fixed size, lock-free Memory Pool with reference counted memory |
| RTT::FunctionFactory | A CommandFactory which delivers commands which execute a FunctionGraph in a Processor |
| RTT::detail::FunctionForwarder< R, FunctorT > | Used to partially specialise the case when returning a void from a functor |
| RTT::detail::FunctionForwarder< R &, FunctorT > | Specialise reference types |
| RTT::FunctionGraph | This class represents a function |
| RTT::FunctionGraphBuilder | This class builds a program consisting of data contained in a program graph tree, based on the Boost Graph Library |
| RTT::detail::Functor< FunctionT > | A functor that stores a function, and DataSources to get the data from |
| RTT::detail::FunctorDataSource0< FunctorT > | These classes are generic DataSources that take a functor, and a number of DataSources corresponding with the arguments of the functor, and use it to get data from |
| RTT::detail::FunctorDataSourceDS0< ComponentT, FunctorT > | Coded for inState("string") the component pointer itself is also stored in a datasource, such that if this datasource is copied, the component pointer is updated |
| RTT::detail::FunctorDataSourceDS1< ComponentT, FunctorT, Arg1T > | Can not encapsulate void functions ! |
| RTT::detail::FunctorDS1< FunctionT > | A functor that stores a function needing one argument, and one DataSource to get the data from |
| RTT::detail::FunctorImpl< 0, FunctionT > | This trivial version (no arguments to manage) is not used by CommandFunctor and ConditionFunctor |
| RTT::detail::FunctorImpl< 1, FunctionT > | A functor that stores a function needing one argument, and one DataSource to get the data from |
| RTT::GenerateDataSource | A function object which returns a vector of DataSources |
| std::greater< const _Tp & > | One of the comparison functors |
| RTT::Handle | The Handle holds the information, and allows manipulation, of a connection between an Event Handler function and the Event itself |
| RTT::Corba::IllegalServer | Thrown if a server does not exist or has the wrong type |
| RTT::Logger::In | Notify the Logger in which 'module' the message occured |
| RTT::IndexedValueDataSource< T, Index, SetType, IPred, APred > | A ValueDataSource of which individual parts can be updated using an index |
| RTT::INIMarshaller< output_stream > | A Marshaller which writes out the properties in MS .INI format |
| RTT::OS::InitFunction | Use this to register a global init function to the StartStopManager |
| RTT::detail::Invoker< F, BaseImpl > | Creates an invocation object with a function signature to invoke and an implementation in which an operator(args) is available which has this signature |
| RTT::MemoryPool< T >::Item | Adds a reference count |
| RTT::FixedSizeMemoryPool< T >::Item | Adds a reference count |
| std::less< const _Tp & > | One of the comparison functors |
| RTT::List< T > | This object represents the default queue implementation used by Orocos objects |
| RTT::ListLocked< T > | A simple lock-based list implementation to append or erase data of type T |
| RTT::ListLockFree< T > | A simple lock-free list implementation to append or erase data of type T |
| RTT::OS::local_allocator< T, Alloc > | A simple local allocator which keeps a small pool which you can grow manually with grow() |
| RTT::detail::LocalCommand< CommandT > | A Command which is dispatched locally to a CommandProcessor |
| RTT::detail::LocalCommandImpl< CommandT > | A Command which is dispatched locally to a CommandProcessor |
| RTT::detail::LocalEvent< Signature > | An Event which calls back local functions |
| RTT::detail::LocalMethod< FunctionT > | A method which executes a local function |
| RTT::LockedQueue< T, ReadPolicy, WritePolicy > | A lock-based queue implementation to enqueue or dequeue a pointer of type T |
| RTT::Logger | A simple logging class to debug/ analyse what is going on in the Orocos system |
| RTT::OS::MainThread | A class which represents the main() thread |
| RTT::MarshallConfiguration< HeaderMarshaller, BodyMarshaller > | Contains the required classes for a full marshalling operation |
| RTT::Marshaller | A Marshaller converts Property objects to a (file/text) format |
| RTT::MarshallerAdaptor< InputStream, DeMarshaller, Marshaller, OutputStream > | Converts one marshaller type to another marshaller |
| RTT::MarshallingAccess | Load and save properties of a TaskContext |
| RTT::MemoryPool< T > | A memory pool in which allocate() and deallocate() are lock-free |
| RTT::Method< FunctionT > | A method which executes a function |
| RTT::detail::MethodBase< F > | The base class for all method implementations |
| RTT::MethodC | A user friendly method to a TaskContext |
| RTT::MethodRepository | This class allows storage and retrieval of Method objects |
| RTT::MultiVector< S, T > | A static allocated Vector |
| RTT::OS::Mutex | An object oriented wrapper around a non recursive mutex |
| RTT::OS::MutexInterface | An interface to a Mutex |
| RTT::OS::MutexLock | MutexLock is a scope based Monitor, protecting critical sections with a Mutex object through locking and unlocking it |
| RTT::OS::MutexRecursive | An object oriented wrapper around a recursive mutex |
| RTT::OS::MutexTimedLock | A MutexTimedLock locks a Mutex object on construction and if successful, unlocks it on destruction of the MutexTimedLock |
| RTT::OS::MutexTryLock | A MutexTryLock tries to lock an Mutex object on construction and if successful, unlocks it on destruction of the MutexTryLock |
| RTT::detail::NA< T > | This class is used to return a 'default' value when no value is available ('Not Available') |
| RTT::detail::NA< void > | Specialisation to return a void |
| RTT::NameServer< _ValueType >::name_iterator | An Iterator to iterate over the registered names |
| RTT::name_not_found_exception | Exception thrown when a factory is requested to create an object with an unknown name |
| RTT::NameServer< _ValueType > | A nameserver for Orocos Device classes |
| RTT::NameServerRegistrator< T > | Utility class to register a given object with a nameserver, and deregister upon destruction |
| RTT::NArityDataSource< function > | A generic N-arity composite DataSource |
| RTT::non_lvalue_args_exception | Exception thrown when a factory is requested to create an object, and one of the arguments needed to be an lvalue (AssignableDataSource) and an rvalue (plain DataSource) was given |
| RTT::NonBlockingPolicy | Use this policy to indicate that you do not want to block on an empty or full buffer, queue, fifo, |
| RTT::NonPeriodicActivity | A ActivityInterface implementation which is run in a SingleThread |
| std::not_equal_to< const _Tp & > | One of the comparison functors |
| RTT::OperationFactory< ResultT > | This factory is a template for creating parts |
| RTT::OperationInterface | The interface for accessing and executing 'operations', being commands, methods, events and attributes |
| RTT::OperatorRepository | This class builds on upon construction all expression operators known to Orocos |
| RTT::Orocos1Demarshaller | A demarshaller which parses data compatible with the previous Orocos property system |
| RTT::Orocos1Marshaller< output_stream > | A marshaller which generates data compatible with the previous Orocos property system |
| Orocos_AnyExpression_i | A servant which serves a RTT::DataSource through the 'Any' methods |
| RTT::parse_exception | This is the uppermost exception class in the parser system |
| RTT::detail::parse_exception_fatal_semantic_error | Parse_exception class that is used for fatal semantic errors for which it was not worth defining a proper exception class |
| RTT::detail::parse_exception_parser_fail | An exception which a parser may throw to indicate that it failed to understand the input, and thus can not interpret its validity |
| RTT::detail::parse_exception_semantic_error | Parse_exception class that is used for various semantic errors for which it was not worth defining a proper exception class |
| RTT::detail::parse_exception_syntactic_error | Parse_exception class that is used for various syntactic errors for which it was not worth defining a proper exception class |
| RTT::ParsedStateMachine | State machine created by the scripting engine which represents a parsed state machine |
| RTT::Parser | This class is the public interface to the Orocos Program Parser Framework |
| RTT::ParserExecutionAccess | The Parser Execution Access provides access to programs and state machines loaded in the execution engine |
| RTT::ParserScriptingAccess | This implementation provides access to the loaded programs and state machines and allows execution of code, using the Orocos parser framework |
| RTT::detail::PeerParser | Get the peer and object from an invocation path like a.b.c.d() |
| RTT::PeriodicActivity | A PeriodicActivity is the general implementation of a Activity which has (realtime) periodic constraints |
| RTT::OS::PeriodicThread | A PeriodicThread executes its step() method (or a RunnableInterface ) periodically |
| RTT::PortInterface | A Port of a task is used to connect it with other tasks using a Connector |
| RTT::rt_std::printstream | The printstream is a stream for printing characters to the terminal window |
| RTT::program_load_exception | This exception is thrown when a program or state machine could not be loaded into a ProgramProcessor or StateMachineProcessor |
| RTT::program_unload_exception | This exception is thrown when a program or state machine could not be unloaded into a ProgramProcessor or StateMachineProcessor |
| RTT::detail::ProgramGraphParser | A Parser for Orocos Program Scripts |
| RTT::ProgramInterface | A Program represents a collection of instructions that can be stepwise executed |
| RTT::ProgramLoader | This class loads and unloads Orocos Program Script and Orocos State Description files to a TaskContext's Processor |
| RTT::ProgramProcessor | This class implements a real-time program processor |
| RTT::ProgramTask | This class represents a program as an TaskObject in the Orocos TaskContext system |
| RTT::Property< T > | A property represents a named value of any type with a description |
| RTT::PropertyBag | A container for holding references to properties |
| RTT::PropertyBagIntrospector | This class fills up a given bag with the results of an introspection |
| RTT::PropertyBagVisitor | A simple introspection interface to visit PropertyBags |
| RTT::PropertyBase | Base class for all properties |
| RTT::PropertyDemarshaller | The default Orocos demarshaller for extracting properties and property bags from a property file |
| RTT::PropertyIntrospection | An interface which all classes which wish to visit a Property should implement |
| RTT::PropertyLoader | Load and save property files to a TaskContext's PropertyBag |
| RTT::PropertyMarshaller | A class for writing a property or propertybag into file |
| RTT::detail::PropertyParser | Get the property and bag from an invocation path like bag.subbag.prop |
| RTT::PropertySequence< T > | A container for a sequence of properties of the same type Property<T> [EXPERIMENTAL] |
| RTT::PulseTrainGeneratorInterface | A generic interface to a pulsetraingenerator for simulation of encoder like behaviour |
| RTT::Queue< T, ReadPolicy, WritePolicy > | This object represents the default queue implementation used by Orocos objects |
| RTT::detail::quickbind< F, O > | A class which binds a Type F to object O |
| RTT::detail::quickbindC< F > | A class which binds a C style function F |
| RTT::ReadBufferPort< T > | A Port to a readable Buffer |
| RTT::ReadDataPort< T > | A Port to a readable Data Connection |
| RTT::ReadInterface< T > | This interface describes a read interface for value types |
| RTT::RealTimeToolkitPlugin | This interface defines the types of the realTime package |
| RTT::ReferenceDataSource< T > | A DataSource which is used to manipulate a reference to an external value |
| RTT::detail::RemoteCommand< CommandT > | A Command which is dispatched remotely to a CommandProcessor |
| RTT::detail::RemoteCommandImpl< CommandT > | A Command which is dispatched remotely to a CommandProcessor |
| RTT::detail::RemoteMethod< MethodT > | A Method which is dispatched remotely to a MethodProcessor |
| RTT::detail::RemoteMethodImpl< MethodT > | A Method which executes a remote function directly |
| RTT::OS::rt_allocator< T > | A real-time malloc allocator which allocates every block with oro_rt_malloc() and deallocates with oro_rt_free() |
| RTT::OS::rt_list< T, Alloc > | Implements a list with real-time insertion/removal of elements |
| RTT_Corba_BufferChannel_i< RTT::detail::UnknownType > | Specialise for when we really don't know this C++ type |
| RTT_Corba_ServiceInterface_i | Implementation |
| RTT::OS::RunnableInterface | A class for running a certain piece of code in a thread |
| RTT::RunnableInterface | This class adds Activity specific semantics to OS::RunnableInterface and sits in the RTT namespace |
| RTT::ScopedHandle | A scoped connection Handle of a (connected) slot which disconnects a slot from a signal in its destructor |
| RTT::ScriptingAccess | This interface allows to load program scripts and state machines and allows execution of code |
| RTT::Corba::ScriptingAccessProxy | A Corba Proxy for the ScriptingAccess class |
| RTT::detail::semantic_parse_exception | A Semantic parse exception means the parser recognised a part of the string, but got into trouble lateron, for example, a missing argument or non existing component |
| RTT::OS::Semaphore | An object oriented wrapper around a counting semaphore |
| RTT::SensorInterface< SensorData > | An interface that describes a general sensor You can read a value/structure |
| RTT::SequentialActivity | The default, thread-less activity for any newly created TaskContext |
| RTT::Corba::Services | Helper class which locates common CORBA services |
| RTT::detail::signal< Signature, SlotFunction > | Very lightweight wrapper around the signalN classes that allows signals to be created where the number of arguments does not need to be part of the class name |
| RTT::SimpleDemarshaller | A simple demarshaller |
| RTT::SimpleMarshaller< o_stream > | A simple marshaller which flattens your property bag into simple types |
| RTT::SimulationActivity | A SimulationActivity is a PeriodicActivity which is used for simulation |
| RTT::SimulationThread | This thread is the simulated real-time periodic thread in the Orocos system |
| RTT::SingleList< DataType_ > | A single-linked single list algorithm invented by Timothy L |
| RTT::OS::SingleThread | This Thread abstraction class represents a single-shot thread which can be started many times |
| RTT::SixaryDataSource< function > | A DataSource which returns the return value of a sixary function |
| RTT::SlaveActivity | An ActivityInterface implementation which executes 'step' upon the invocation of 'execute()', which is called by another Activity ('master') |
| RTT::SortedList< DataType_ > | A single-linked sorted list algorithm invented by Timothy L |
| RTT::OS::StartStopManager | This manager starts and stops all globally registered start/stop functions, without a particular order |
| RTT::StateDescription | This class represents a state with all actions stored in an external program |
| RTT::detail::StateGraphParser | This is not a parser in the Boost.spirit sense of the word, it's just a class used to hold the parser and semantic actions |
| RTT::StateInterface | A State contains an entry, run, handle and exit program |
| RTT::StateMachine | A hierarchical StateMachine which is loaded in the Program Processor |
| RTT::StateMachineProcessor | This class implements a real-time state machine executor |
| RTT::StateMachineTask | This class represents a stateMachine as a TaskObject in the Orocos TaskContext system |
| RTT::StatementProcessor | This class parses and executes a single scripting statement |
| RTT::ProgramInterface::Status | Placeholder of the ProgramStatus |
| RTT::StateMachine::Status | Enumerates all possible state machine statuses |
| RTT::stdvector_varargs_ctor< T > | See NArityDataSource which requires a function object like this one |
| RTT::StdVectorBuilder< T > | Constructs an array with n elements, which are given upon construction time |
| RTT::rt_std::streambufs | A base class for all stream buffer operations |
| RTT::StreamProcessor< Stream > | An interface for setting and getting a stream object |
| RTT::rt_std::stringbufs | A streambufs implementation based on strings |
| RTT::rt_std::stringstreams | Stringstreams, are not guaranteed to be hard realtime |
| RTT::detail::SubscriberBase< Signature > | The base class of Subscriber implementations |
| RTT::detail::syntactic_parse_exception | A normal syntactic parse exception means the parser recognised the input, but got stuck later due to a syntactic error, like a missing brace |
| RTT::TableHeaderMarshaller< o_stream > | A Marshaller for generating headers of tables |
| RTT::TableMarshaller< o_stream > | A Marshaller for generating a stream of numbers, ordered in columns |
| RTT::TaskContext | A TaskContext exports the commands, methods, events, properties and ports a task has |
| RTT::TaskCore | The minimal Orocos task |
| RTT::TaskObject | A task object groups a set of commands and methods (operations) which may be invoked |
| RTT::TemplateContainerTypeInfo< T, IndexType, SetType, IPred, APred, has_ostream > | Template for containers |
| RTT::TemplateIndexTypeInfo< T, IndexType, SetType, IPred, APred, has_ostream > | Template for indexable types |
| RTT::TemplateTypeInfo< T, use_ostream > | This helper class allows user types to be added to Orocos |
| RTT::TernaryDataSource< function > | A DataSource which returns the return value of a ternary function |
| RTT::OS::Thread | A Thread object executes user code in its own thread |
| RTT::OS::ThreadInterface | A thread which is being run (or runs a RunnableInterface) |
| RTT::Timer | This class allows to define a timer object which can be armed in single shot and periodic mode |
| RTT::TimerThread | This Periodic Thread is meant for executing a PeriodicActivity object periodically |
| RTT::TimeService | The TimeService is used for system-wide time keeping and conversions |
| RTT::Toolkit | This class allows the Orocos Real-Time Toolkit to be extended with additional toolkits (ToolkitPlugin), such as for kinematics or any library foreign to Orocos |
| RTT::ToolkitPlugin | This interface defines how additional toolkits are loaded into Orocos |
| RTT::TransportPlugin | A class which registers TransportProtocol instances to types |
| RTT::TryCommand | A command which tries another command and stores the result in a DataSource<bool> |
| RTT::TryCommandResult | Returns the (accept/reject) status of another command |
| RTT::TypeBuilder | This interface describes how constructors work |
| RTT::TypeInfo | A class for representing a user type, and which can build instances of that type |
| RTT::TypeInfoName< T > | This helper class allows only type names to be added to Orocos |
| RTT::TypeInfoRepository | This class contains all known types to Orocos |
| RTT::detail::TypeTransporter | This interface defines the function a transport protocol must support in order to allow Orocos components to remotely communicate data |
| RTT::UnaryDataSource< function > | A DataSource which returns the return value of a unary function |
| RTT::detail::UnaryOp | UnaryOperator contains information on some unary operator that operates on one arg of a certain type |
| RTT::detail::UnaryOperator< function > | An operator which reads a single DataSource and returns a modified result |
| RTT::detail::UnboundDataSource< BoundType > | A special DataSource only to be used for if you understand the copy()/clone() semantics very well |
| RTT::detail::UnMember< F > | This class converts a member function type R (X::)(Args) to a plain function type R (Args) which can be used by a boost::function or similar |
| RTT::detail::UnPointer< F > | Convert a function R (X::)(Args) to a plain function signature R(X::,Args) |
| RTT::NameServer< _ValueType >::value_iterator | An Iterator to iterate over the registered objects |
| RTT::detail::ValueChangeParser | This class is responsible for parsing constant definitions, variable definitions, variable change instructions, and alias definitions |
| RTT::ValueDataSource< T > | A simple, yet very useful DataSource, which keeps a value, and returns it in its get() method |
| RTT::detail::ValueParser | A class for parsing const values |
| RTT::VertexNode | This class represents elements in a program tree |
| RTT::WriteBufferPort< T > | A Port to a writable Buffer |
| RTT::WriteDataPort< T > | A Port to a writable Data Connection |
| RTT::WriteInterface< T > | This interface describes a write interface for value types |
| RTT::wrong_number_of_args_exception | Exception thrown when a factory is requested to create an object but the wrong number of arguments was given |
| RTT::wrong_types_of_args_exception | Exception thrown when a factory is requested to create an object, but a wrong argument type was given |
| RTT::XMLDemarshaller< input_stream > | Unimplemented counterpart of XMLMarshaller |
| RTT::XMLMarshaller< o_stream > | Marshalls a PropertyBag to a non standard XML format |
| RTT::XMLRPCDemarshaller | A Demarshaller for the XMLRPC Protocol |
| RTT::XMLRPCMarshaller< output_stream > | Outputs a Property or PropertyBag into a text stream in the XML-RPC format |
