Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
RTT::ActionInterfaceBased on the software pattern 'action', this interface allows execution of action objects
RTT::Corba::ActionProxyThis class manages the access of remote Action Corba Servers
RTT::ActivityAn Activity is an object that represents a thread
RTT::ActivityInterfaceInterface 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::AnalogInInterfaceAn interface for reading analog input, like for addressing a whole subdevice in comedi
RTT::AnalogInputA class representing an analog input channel
RTT::AnalogOutInterfaceAn interface for writing analog output, like for addressing a whole subdevice in comedi
RTT::AnalogOutputA 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::AnyDataSourceA DataSource which holds an any value and returns it in its get() method
RTT::Corba::ApplicationServerA 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::ArgumentDescriptionDescription of one Argument of a Command
RTT::detail::ArgumentsParserThis 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::AsynchCommandDecoratorBased 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::AtomicIntC++ 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::AttributeBaseAn attribute is a minimalistic, named placeholder for data
RTT::AttributeRepositoryA class for keeping track of Attribute, Constant and Property objects of a TaskContext
RTT::AxisInterfaceThe AxisInterface represents an axis from a control point of view
RTT::bad_assignmentThis exception is thrown if the target and source type of an assignment of a DataSource with a DataSourceBase differ
RTT::rt_std::basic_iostreamsAn IO stream based on strings
RTT::rt_std::basic_istreamsAn basic_istream is a stream which can be read
RTT::rt_std::basic_ostreamsAn basic_ostreams is a stream which can be written to
RTT::rt_std::basic_streamsThis 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::BlockingEventProcessorThe Blocking EventProcessor, extended with a blocking implementation, waiting for one Event to complete in its loop()
RTT::BlockingPolicyUse 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::BufferBaseAny 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::CalibrationInterfaceA class which will calibrate a sensor
RTT::CallbackInterfaceGeneric callback interface
RTT::OS::CleanupFunctionUse this to register a global cleanup function to the StartStopManager
RTT::CleanupHandleA 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::CommandCA user friendly Command to a TaskContext
RTT::CommandCompositeBased on the software pattern 'composite', this class RTT_API allows composing command objects into one command object
RTT::CommandCounterThis command increments a counter when executed
RTT::CommandDataSourceA Command which evaluates a DataSourceBase and always returns true
RTT::CommandDataSourceBoolA Command which evaluates a DataSource<bool> and returns the result of get()
RTT::CommandDispatchDispatch a CommandInterface to a CommandProcessor
RTT::CommandDS< CommandT >A Command storage container
RTT::CommandExecFunctionA command which queues (dispatches) a FunctionFraph for execution in a ProgramProcessor
RTT::detail::CommandFunctionA 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::CommandIllegalA Command indicating that an error was encountered somewhere, most likely during the construction of another command
RTT::CommandNOPThe empty command
RTT::detail::CommandParserThis class parses commands
RTT::CommandProcessorThis class implements an Orocos command processor
RTT::Corba::CommandProxyThis class manages the access of remote Command Corba Servers
RTT::CommandRepositoryA command repository stores a number of commands from a Task which can be used by other tasks or from scripts
RTT::CommandStringThis command displays a string when executed
RTT::detail::CommonParserThis class contains some very common parser definitions
RTT::CompletionProcessorAn activity which executes asynchronous (defered) handlers of Events
RTT::ConditionBinaryCompositeANDCompose an 'AND' function of two Conditions
RTT::ConditionBoolDataSourceA Condition which holds a boolean DataSource
RTT::ConditionBoolPropertyConditionBoolProperty is a Condition which reads out a Property<bool>
RTT::ConditionCompare< T, compare_op >A general compare condition
RTT::ConditionDSDurationA conditional that evaluates true after a certain time (in seconds) has passed, given by a DataSource
RTT::ConditionDurationA conditional that evaluates true after a certain time has passed
RTT::ConditionExecFunctionA condition which checks if a CommandExecFunction is done or not
RTT::ConditionExpireA conditional that evaluates true until a certain time has elapsed since construction or the last reset()
RTT::ConditionFalseA conditional that evaluates false
RTT::detail::ConditionFunctionA 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::ConditionInterfaceThis interface represents the concept of a condition which can be evaluated and return true or false
RTT::ConditionInvertA conditional that evaluates to the inverse of another Condition
RTT::ConditionOnceA conditional that evaluates the first time true and afterwards always false (or vice versa)
RTT::detail::ConditionParserThis is a class containing a parse function for conditions
RTT::ConditionTrueA conditional that evaluates true
RTT::ConfigurationInterfaceGeneric run-time class configuration interface
RTT::ConfiguratorA class which configures other objects in small steps spread in time
RTT::ConnectionCA 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::ConnectionInterfaceAn Object which manages and maintains a communication connection between Ports
RTT::ConnectionTypesEnumerates 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::ControlTaskProxyThis class manages the access of remote TaskContext Corba Servers and a Corba Object Request Broker (Orb) which connects to these servers
RTT::Corba::ControlTaskServerThis 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::CorbaCommandFactoryThis 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::CorbaMethodFactoryA local factory for creating remote Corba methods
RTT::Corba::CorbaPortA port used by ControlTaskProxy objects to connect a corba data or buffer channel as an Orocos Port
RTT::Corba::CorbaServiceA 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::DataCallParserThis 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::DataFlowInterfaceThe 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::DataSourceBaseThe base class for all DataSource's
RTT::DataSourceCommandA class that wraps a Command in a DataSource<bool> interface
RTT::DataSourceConditionA 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::DataSourceTimeA 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::DemarshallerAn interface for extracting properties from a format
RTT::DigitalInInterfaceA class representing a Digital Input device from which a maximum of 32 bits can be read at once
RTT::DigitalInputA class representing a switch which can be on or off
RTT::DigitalOutInterfaceA class representing a Digital Output device which can read or write a maximum of 32 bits at once
RTT::DigitalOutputA DigitalOut represents any on/off output
RTT::DispatchActionAn action which invokes a dispatch command in execute()
RTT::DispatchInterfaceDispatch 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::DotOpThe Dot Operator allows access to members of composite types, such as in frame.pos.x
RTT::detail::DotOperator< function >Dot : '
RTT::DriveInterfaceA Drive Object controls a single axis
RTT::EdgeConditionThis class represents a conditional branch in a program tree
RTT::EmptyHeaderMarshaller< o_stream >A Dummy Empty Header Marshaller
RTT::EmptyMarshallerA Dummy Empty Marshaller
RTT::EmptyTypeInfoEmpty implementation of TypeInfo interface
RTT::EncoderInterfaceThe most generic interface to a position/turn counter, for encoding positions
RTT::eol_skip_functorDue 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::EvalCommandEvaluates a DataSource<bool> in a command
RTT::EvalCommandResultThe 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::EventCA user friendly event of a TaskContext
RTT::detail::EventCallBackClass 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::EventDrivenActivityAn Event-driven ActivityInterface implementation
RTT::detail::EventHookBaseCreate end-user event handles
RTT::detail::EventHookGenerator< EventT >Generate EventHook depending on number of arguments
RTT::EventProcessorAn Asynchronous Event Processor, which catches events and executes the asynchronous callbacks in its RunnableInterface::step()
RTT::EventServiceThe EventService represents the event interface
RTT::ExecutionAccessThe ExecutionAccess provides access to programs and state machines loaded in the execution engine
RTT::ExecutionEngineAn execution engine serialises (executes one after the other) the execution of all commands, programs, state machines and incomming events for a task
RTT::detail::ExpressionParserHow we parse: this parser works like a stack-based RPN calculator
RTT::Corba::ExpressionProxyThis class manages the access of remote Expression Corba Servers
RTT::Corba::ExpressionServerThis class manages the access of local Expression Corba Servants and Servers
RTT::detail::fatal_semantic_parse_exceptionA 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_exceptionA 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_exceptionThis 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::FindPropA function object for finding a Property by name
RTT::PropertySequence< T >::FindPropA function object for finding a Property by name
RTT::FixedSizeMemoryPool< T >A fixed size, lock-free Memory Pool with reference counted memory
RTT::FunctionFactoryA 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::FunctionGraphThis class represents a function
RTT::FunctionGraphBuilderThis 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::GenerateDataSourceA function object which returns a vector of DataSources
std::greater< const _Tp & >One of the comparison functors
RTT::HandleThe Handle holds the information, and allows manipulation, of a connection between an Event Handler function and the Event itself
RTT::Corba::IllegalServerThrown if a server does not exist or has the wrong type
RTT::Logger::InNotify 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::InitFunctionUse 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 >::ItemAdds a reference count
RTT::FixedSizeMemoryPool< T >::ItemAdds 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::LoggerA simple logging class to debug/ analyse what is going on in the Orocos system
RTT::OS::MainThreadA class which represents the main() thread
RTT::MarshallConfiguration< HeaderMarshaller, BodyMarshaller >Contains the required classes for a full marshalling operation
RTT::MarshallerA Marshaller converts Property objects to a (file/text) format
RTT::MarshallerAdaptor< InputStream, DeMarshaller, Marshaller, OutputStream >Converts one marshaller type to another marshaller
RTT::MarshallingAccessLoad 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::MethodCA user friendly method to a TaskContext
RTT::MethodRepositoryThis class allows storage and retrieval of Method objects
RTT::MultiVector< S, T >A static allocated Vector
RTT::OS::MutexAn object oriented wrapper around a non recursive mutex
RTT::OS::MutexInterfaceAn interface to a Mutex
RTT::OS::MutexLockMutexLock is a scope based Monitor, protecting critical sections with a Mutex object through locking and unlocking it
RTT::OS::MutexRecursiveAn object oriented wrapper around a recursive mutex
RTT::OS::MutexTimedLockA MutexTimedLock locks a Mutex object on construction and if successful, unlocks it on destruction of the MutexTimedLock
RTT::OS::MutexTryLockA 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_iteratorAn Iterator to iterate over the registered names
RTT::name_not_found_exceptionException 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_exceptionException 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::NonBlockingPolicyUse this policy to indicate that you do not want to block on an empty or full buffer, queue, fifo,
RTT::NonPeriodicActivityA 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::OperationInterfaceThe interface for accessing and executing 'operations', being commands, methods, events and attributes
RTT::OperatorRepositoryThis class builds on upon construction all expression operators known to Orocos
RTT::Orocos1DemarshallerA 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_iA servant which serves a RTT::DataSource through the 'Any' methods
RTT::parse_exceptionThis is the uppermost exception class in the parser system
RTT::detail::parse_exception_fatal_semantic_errorParse_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_failAn 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_errorParse_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_errorParse_exception class that is used for various syntactic errors for which it was not worth defining a proper exception class
RTT::ParsedStateMachineState machine created by the scripting engine which represents a parsed state machine
RTT::ParserThis class is the public interface to the Orocos Program Parser Framework
RTT::ParserExecutionAccessThe Parser Execution Access provides access to programs and state machines loaded in the execution engine
RTT::ParserScriptingAccessThis implementation provides access to the loaded programs and state machines and allows execution of code, using the Orocos parser framework
RTT::detail::PeerParserGet the peer and object from an invocation path like a.b.c.d()
RTT::PeriodicActivityA PeriodicActivity is the general implementation of a Activity which has (realtime) periodic constraints
RTT::OS::PeriodicThreadA PeriodicThread executes its step() method (or a RunnableInterface ) periodically
RTT::PortInterfaceA Port of a task is used to connect it with other tasks using a Connector
RTT::rt_std::printstreamThe printstream is a stream for printing characters to the terminal window
RTT::program_load_exceptionThis exception is thrown when a program or state machine could not be loaded into a ProgramProcessor or StateMachineProcessor
RTT::program_unload_exceptionThis exception is thrown when a program or state machine could not be unloaded into a ProgramProcessor or StateMachineProcessor
RTT::detail::ProgramGraphParserA Parser for Orocos Program Scripts
RTT::ProgramInterfaceA Program represents a collection of instructions that can be stepwise executed
RTT::ProgramLoaderThis class loads and unloads Orocos Program Script and Orocos State Description files to a TaskContext's Processor
RTT::ProgramProcessorThis class implements a real-time program processor
RTT::ProgramTaskThis 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::PropertyBagA container for holding references to properties
RTT::PropertyBagIntrospectorThis class fills up a given bag with the results of an introspection
RTT::PropertyBagVisitorA simple introspection interface to visit PropertyBags
RTT::PropertyBaseBase class for all properties
RTT::PropertyDemarshallerThe default Orocos demarshaller for extracting properties and property bags from a property file
RTT::PropertyIntrospectionAn interface which all classes which wish to visit a Property should implement
RTT::PropertyLoaderLoad and save property files to a TaskContext's PropertyBag
RTT::PropertyMarshallerA class for writing a property or propertybag into file
RTT::detail::PropertyParserGet 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::PulseTrainGeneratorInterfaceA 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::RealTimeToolkitPluginThis 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_iImplementation
RTT::OS::RunnableInterfaceA class for running a certain piece of code in a thread
RTT::RunnableInterfaceThis class adds Activity specific semantics to OS::RunnableInterface and sits in the RTT namespace
RTT::ScopedHandleA scoped connection Handle of a (connected) slot which disconnects a slot from a signal in its destructor
RTT::ScriptingAccessThis interface allows to load program scripts and state machines and allows execution of code
RTT::Corba::ScriptingAccessProxyA Corba Proxy for the ScriptingAccess class
RTT::detail::semantic_parse_exceptionA 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::SemaphoreAn object oriented wrapper around a counting semaphore
RTT::SensorInterface< SensorData >An interface that describes a general sensor You can read a value/structure
RTT::SequentialActivityThe default, thread-less activity for any newly created TaskContext
RTT::Corba::ServicesHelper 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::SimpleDemarshallerA simple demarshaller
RTT::SimpleMarshaller< o_stream >A simple marshaller which flattens your property bag into simple types
RTT::SimulationActivityA SimulationActivity is a PeriodicActivity which is used for simulation
RTT::SimulationThreadThis 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::SingleThreadThis 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::SlaveActivityAn 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::StartStopManagerThis manager starts and stops all globally registered start/stop functions, without a particular order
RTT::StateDescriptionThis class represents a state with all actions stored in an external program
RTT::detail::StateGraphParserThis 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::StateInterfaceA State contains an entry, run, handle and exit program
RTT::StateMachineA hierarchical StateMachine which is loaded in the Program Processor
RTT::StateMachineProcessorThis class implements a real-time state machine executor
RTT::StateMachineTaskThis class represents a stateMachine as a TaskObject in the Orocos TaskContext system
RTT::StatementProcessorThis class parses and executes a single scripting statement
RTT::ProgramInterface::StatusPlaceholder of the ProgramStatus
RTT::StateMachine::StatusEnumerates 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::streambufsA base class for all stream buffer operations
RTT::StreamProcessor< Stream >An interface for setting and getting a stream object
RTT::rt_std::stringbufsA streambufs implementation based on strings
RTT::rt_std::stringstreamsStringstreams, are not guaranteed to be hard realtime
RTT::detail::SubscriberBase< Signature >The base class of Subscriber implementations
RTT::detail::syntactic_parse_exceptionA 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::TaskContextA TaskContext exports the commands, methods, events, properties and ports a task has
RTT::TaskCoreThe minimal Orocos task
RTT::TaskObjectA 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::ThreadA Thread object executes user code in its own thread
RTT::OS::ThreadInterfaceA thread which is being run (or runs a RunnableInterface)
RTT::TimerThis class allows to define a timer object which can be armed in single shot and periodic mode
RTT::TimerThreadThis Periodic Thread is meant for executing a PeriodicActivity object periodically
RTT::TimeServiceThe TimeService is used for system-wide time keeping and conversions
RTT::ToolkitThis 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::ToolkitPluginThis interface defines how additional toolkits are loaded into Orocos
RTT::TransportPluginA class which registers TransportProtocol instances to types
RTT::TryCommandA command which tries another command and stores the result in a DataSource<bool>
RTT::TryCommandResultReturns the (accept/reject) status of another command
RTT::TypeBuilderThis interface describes how constructors work
RTT::TypeInfoA 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::TypeInfoRepositoryThis class contains all known types to Orocos
RTT::detail::TypeTransporterThis 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::UnaryOpUnaryOperator 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_iteratorAn Iterator to iterate over the registered objects
RTT::detail::ValueChangeParserThis 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::ValueParserA class for parsing const values
RTT::VertexNodeThis 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_exceptionException thrown when a factory is requested to create an object but the wrong number of arguments was given
RTT::wrong_types_of_args_exceptionException 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::XMLRPCDemarshallerA Demarshaller for the XMLRPC Protocol
RTT::XMLRPCMarshaller< output_stream >Outputs a Property or PropertyBag into a text stream in the XML-RPC format
Generated on Thu Dec 23 13:22:38 2010 for Orocos Real-Time Toolkit by  doxygen 1.6.3