Orocos Real-Time Toolkit  2.6.0
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
RTT::internal::ActionAliasAssignableDataSource< T >An AssignableDataSource which is used to execute an action and then return the value of another DataSource
RTT::internal::ActionAliasDataSource< T >A DataSource which is used to execute an action and then return the value of another DataSource
RTT::base::ActionInterfaceBased on the software pattern 'command', this interface allows execution of action objects
RTT::ActivityAn Activity is an object that represents a thread
RTT::base::ActivityInterfaceInterface to start/stop and query a Activity
RTT::internal::AddMember< F, Class >The inverse of UnMember
RTT::AliasThis class is the most basic Attribute implementation (only suitable for reading a internal::DataSource), does not allow any assignment, just stores a internal::DataSourceBase, and returns it
RTT::internal::AliasDataSource< T >A DataSource which is used to mirror another datasource
RTT::dev::AnalogInInterfaceAn interface for reading analog input, like for addressing a whole subdevice in comedi
RTT::dev::AnalogInputA class representing an analog input channel
RTT::dev::AnalogOutInterfaceAn interface for writing analog output, like for addressing a whole subdevice in comedi
RTT::dev::AnalogOutputA class representing an analog output channel
RTT::corba::AnyConversion< Type >This class converts a given application-specific type to a CORBA::Any object and vice versa
RTT::corba::AnyConversion< ConnPolicy >This specialisation uses the toRTT() and toCORBA functions for converting between RTT::ConnPolicy and RTT::corba::CConPolicy
RTT::corba::AnyConversion< std::map< T1, T2 > >Use for the conversion of a std::map of C++ types to a two Corba sequences, given the conversions between the C++ types and the Corba types
RTT::corba::AnyConversion< std::pair< T1, T2 > >Use for the conversion of a std::pair of C++ types to a two Corba sequences, given the conversions between the C++ types and the Corba types
RTT::corba::AnyConversion< std::vector< T > >Use for the conversion of a std::vector of C++ type to a Corba sequence, given the conversion between the C++ type and the Corba type
RTT::corba::AnyConversionHelper< Type, _CorbaType >Used for the conversion of types that are binary compatible between CORBA type and std C++ type
RTT::corba::AnyDataSourceA internal::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::internal::ArgMember< F >A complexer variant of UnMember: Convert a member function type to a function type which contains the object as first argument
RTT::ArgumentDescriptionDescription of one Argument of a Command
RTT::scripting::ArgumentsParserThis is a parser that you construct to parse a set of arguments
RTT::internal::ArrayDataSource< T >A DataSource that holds a fixed size array, using the types::carray class
RTT::internal::ArrayPartDataSource< T >A DataSource which is used to manipulate a reference to a part of a data source holding a C-style array of elements
RTT::internal::AssignableDataSource< T >A DataSource which has set() methods
RTT::internal::AssignCommand< T, S >This is a command that will assign the value of an expression to another at runtime
RTT::internal::AssignHelper< Seq, Data, Enable >Helper class for avoiding assigning a bare pointer to a shared_ptr data source
RTT::internal::AStore< T >Store a bound argument which may be a reference, const reference or any other type
RTT::os::AtomicIntC++ abstraction of atomic integer operations
RTT::internal::AtomicMWSRQueue< T >Create an atomic, non-blocking Multi-Writer Single-Reader FIFO for storing a pointer T by value
RTT::internal::AtomicQueue< T >Create an atomic, non-blocking single ended queue (FIFO) for storing a pointer to T
RTT::Attribute< T >An Attribute has a name and contains data which can be set and get
RTT::base::AttributeBaseAn attribute is a minimalistic, named placeholder for data
RTT::dev::AxisInterfaceThe AxisInterface represents an axis from a control point of view
RTT::internal::bad_assignmentThis exception is thrown if the target and source type of an assignment of a DataSource with a base::DataSourceBase differ
RTT::os::basic_iostreamsAn IO stream based on strings
RTT::os::basic_istreamsAn basic_istream is a stream which can be read
RTT::os::basic_ostreamsAn basic_ostreams is a stream which can be written to
RTT::os::basic_streamsThis is a stream class for use in limited environments
RTT::mqueue::binary_data_iarchiveThis archive is capable of loading objects of serialization level 1 and 2 from a binary, non-portable format
RTT::mqueue::binary_data_oarchiveThis archive is capable of saving objects of serialization level 1 and 2 in a binary, non-portable format
RTT::internal::BinaryDataSource< function >A generic binary composite DataSource
RTT::types::BinaryOperator< function >An operator which reads a two DataSources and returns a modified result
RTT::internal::BindStorage< ToBind >A helper-class for the Command implementation which stores the command and collition function objects
RTT::internal::BindStorageImpl< 0, ToBind >When no arguments are to be stored, the implementation stores the function in a boost::function object
RTT::internal::BindStorageImpl< 1, ToBind >Stores a pointer to a function and its arguments
RTT::types::BoolTypeInfoWrite boolean as 'true' or 'false'
RTT::types::BoostArrayTypeInfo< T, has_ostream >Template for data types that are of type boost::array<U,int>
RTT::base::Buffer< T >This object represents the default thread-safe buffer implementation used by Orocos objects
RTT::base::BufferBaseAny Buffer has a capacity, size and can be empty or full
RTT::base::BufferInterface< T >A Buffer is an object which is used to store (Push) and retrieve (Pop) values from
RTT::base::BufferLocked< T >Implements a very simple blocking thread-safe buffer, using mutexes (locks)
RTT::base::BufferLockFree< T >A Lock-free buffer implementation to read and write data of type T in a FIFO way
RTT::base::BufferUnSync< T >Implements a not threadsafe buffer
RTT::dev::CalibrationInterfaceA class which will calibrate a sensor
RTT::scripting::CallFunctionAn action which calls a FunctionFraph for execution in a ExecutionEngine
RTT::corba::CArgumentDescriptionWhen querying an operation for the kinds of arguments it takes, this structure is returned for each argument
RTT::types::carray< T >Wraps a C array such that we can return a C array from a DataSource
RTT::types::CArrayTypeInfo< T, has_ostream >Template for data types that are C-style arrays
RTT::corba::CCallInterruptedIs thrown if the calling or sending of an operation was interrupted
RTT::corba::CChannelElementRepresents the basic channel element interface for reading, writing and disconnecting a channel
RTT::corba::CConfigurationInterfaceExposes both attributes and properties of a service
RTT::corba::CDataFlowInterfaceAn interface to access the dataflow of a CControlTask object
RTT::corba::CDataFlowInterface_iRepresents a remote data flow interface
RTT::internal::ChannelBufferElement< T >A connection element that can store a fixed number of data samples
RTT::internal::ChannelDataElement< T >A connection element that stores a single data sample
RTT::base::ChannelElement< T >A typed version of ChannelElementBase
RTT::base::ChannelElementBaseIn the data flow implementation, a channel is created by chaining ChannelElementBase objects
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) the connection object in its destructor
RTT::corba::CNoCorbaTransportEmitted during connections, when there is no CORBA transport defined for the data type of the given ports
RTT::corba::CNoSuchNameExceptionIs thrown when an operation does not exist
RTT::corba::CNoSuchPortExceptionEmitted when information is requested on a port that does not exist
RTT::internal::Collect< F, BaseImpl >This struct takes the user's Function signature F and transforms it to the form required in the CollectImpl template specialisations
RTT::internal::CollectBase< F >This struct takes the user's Function signature F and transforms it to the form required in the CollectBaseImpl template specialisations
RTT::internal::CollectType< F >This helper struct decomposes F and creates Ft, as required by CollectBaseImpl
RTT::scripting::CommandCompositeBased on the software pattern 'composite', this class RTT_SCRIPTING_API allows composing command objects into one command object
RTT::scripting::CommandCounterThis command increments a counter when executed
RTT::scripting::CommandDataSourceA Command which evaluates a base::DataSourceBase and always returns true
RTT::scripting::CommandDataSourceBoolA Command which evaluates a internal::DataSource<bool> and returns the result of get()
RTT::scripting::CommandFunctionA functor with the base::ActionInterface, for the case where the functor is a bool(void)
RTT::scripting::CommandIllegalA Command indicating that an error was encountered somewhere, most likely during the construction of another command
RTT::scripting::CommandNOPThe empty command
RTT::scripting::CommandStringThis command displays a string when executed
RTT::scripting::CommonParserThis class contains some very common parser definitions
RTT::ComponentFactoriesA global variable storing all component factories added with ORO_LIST_COMPONENT_TYPE
RTT::ComponentFactoryLoader< C >A helper class storing a single component factory in case of static library deployments
RTT::types::CompositionFactoryA factory for composing/decomposing and converting types to a form suitable for persistent storage, such as an XML file
RTT::os::ConditionAn object oriented wrapper around a condition variable
RTT::scripting::ConditionBinaryCompositeANDCompose an 'AND' function of two Conditions
RTT::scripting::ConditionBoolDataSourceA Condition which holds a boolean DataSource
RTT::scripting::ConditionBoolPropertyConditionBoolProperty is a Condition which reads out a Property<bool>
RTT::scripting::ConditionCacheA conditional that evaluates and caches another Condition
RTT::scripting::ConditionCompare< T, compare_op >A general compare condition
RTT::scripting::ConditionDSDurationA conditional that evaluates true after a certain time (in seconds) has passed, given by a DataSource
RTT::scripting::ConditionDurationA conditional that evaluates true after a certain time has passed
RTT::scripting::ConditionExpireA conditional that evaluates true until a certain time has elapsed since construction or the last reset()
RTT::scripting::ConditionFalseA conditional that evaluates false
RTT::scripting::ConditionFunctionA functor with the ConditionInterface, for the case where the functor is a bool(void)
RTT::scripting::ConditionInterfaceThis interface represents the concept of a condition which can be evaluated and return true or false
RTT::scripting::ConditionInvertA conditional that evaluates to the inverse of another Condition
RTT::scripting::ConditionOnceA conditional that evaluates the first time true and afterwards always false (or vice versa)
RTT::scripting::ConditionParserThis is a class containing a parse function for conditions
RTT::scripting::ConditionTrueA conditional that evaluates true
RTT::ConfigurationInterfaceA class for keeping track of Attribute, Constant and Property objects of a TaskContext
RTT::internal::ConnectionBaseA connection 'memorises' the connection between an event and an event handler function
RTT::internal::ConnectionManagerManages connections between ports
RTT::internal::ConnFactoryThis class provides the basic tools to create channels that represent connections between two ports
RTT::internal::ConnIDThis class is used in places where a permanent representation of a reference to a connection is needed
RTT::internal::ConnInputEndpoint< T >This is a channel element that represents the input endpoint of a connection, i.e
RTT::internal::ConnOutputEndpoint< T >This is a channel element that represents the output endpoint of a connection, i.e
RTT::ConnPolicyA connection policy object describes how a given connection should behave
RTT::Constant< T >As opposed to a Attribute, a Constant can not be assigned to a new value after creation
RTT::internal::ConstantDataSource< T >A DataSource which holds a constant value and returns it in its get() method
RTT::internal::ConstReferenceDataSource< T >A DataSource which is used to read a const reference to an external value
RTT::scripting::ConstructorParserParses type constructor syntax
RTT::corba::COperationInterfaceExposes the operations this service offers
RTT::corba::CorbaDispatcherThis object sends over data flow messages from local buffers to a remote channel element
RTT::corba::CorbaFallBackProtocolThis protocol is used for all types which did not get a protocol
RTT::corba::CorbaLibPluginThe CORBA transport plugin
CorbaOperationCallerCallCalls a CORBA method
CorbaOperationCallerCollectCollects a CORBA method
RTT::corba::CorbaOperationCallerFactoryA local factory for creating remote Corba methods
RTT::corba::CorbaTemplateProtocol< T >For each transportable type T, specify the conversion functions
RTT::corba::CorbaTypeTransporterExtends the TypeTransporter in order to allow the creation of channel elements or output halves for a given type
RTT::marsh::CPFMarshaller< std::ostream >A class for marshalling a property or propertybag into a component property description, following the CORBA 3 standard
RTT::internal::create_sequence< List >This class can create three kinds of Boost Fusion Sequences
RTT::internal::create_sequence_helperHelper to convert a single data source base to a DataSource or AssignableDataSource
RTT::corba::CRemoteChannelElementThe advanced channel element interface, used by Orocos to relay over-CORBA data flow connections
RTT::corba::CRemoteChannelElement_iBase class for CORBA channel servers
RTT::corba::CSendHandleA handler object that allows us to collect the results of a send
RTT::corba::CServiceAn Orocos Service which hosts operations, attributes and properties
RTT::corba::CServiceRequesterAn Orocos Required Service
RTT::corba::CTaskContextA CTaskContext is the main entry point of a distributed component and maps to a RTT::TaskContext
RTT::corba::CWrongArgumentExceptionIs thrown when a wrong argument number is queried
RTT::corba::CWrongNumbArgExceptionIs thrown when a wrong number of arguments is provided
RTT::corba::CWrongTypeArgExceptionIs thrown when a wrong type of arguments is provided
RTT::Logger::DThis hidden struct stores all data structures required for logging
RTT::scripting::DataCallParserThis parser parses a call of the form "a.b( arg1, arg2, ..., argN )"
RTT::DataFlowInterfaceThe Interface of a TaskContext which exposes its data-flow ports
RTT::base::DataObject< T >This object represents the default thread-safe data object implementation used by Orocos objects
RTT::internal::DataObjectDataSource< T >A DataSource which is used to read a DataObject
RTT::base::DataObjectInterface< T >A DataObjectInterface implements multi-threaded read/write solutions
RTT::base::DataObjectLocked< T >A class which provides locked/protected access to one typed element of data
RTT::base::DataObjectLockFree< T >This DataObject is a Lock-Free implementation, such that reads and writes can happen concurrently without priority inversions
RTT::base::DataObjectUnSync< T >A class which provides unprotected (not thread-safe) access to one typed element of data
RTT::internal::DataSource< T >DataSource is a base class representing a generic way to read data of type T
RTT::internal::DataSourceArgStorage< A >Partial specialisations for storing a (const) reference or not reference The trick here is to take a (const) reference data source to something that was already a reference, and copy to a value data source for something that is plain value
RTT::internal::DataSourceArgStorage< A & >Partial specialisations for storing a reference
RTT::internal::DataSourceArgStorage< A const & >Partial specialisations for storing a const reference
RTT::base::DataSourceBaseThe base class for all internal data representations
RTT::internal::DataSourceCommandA class that wraps a Command in a internal::DataSource<bool> interface
RTT::scripting::DataSourceConditionA class that wraps a Condition in a internal::DataSource<bool> interface
RTT::corba::DataSourceProxy< T >Mirrors a remote DataSource
RTT::internal::DataSourceResultStorage< R >Partial specialisations for storing a void, not a void or reference Wraps around RStore
RTT::internal::DataSourceResultStorage< R const & >
RTT::internal::DataSourceStorage< DataType >A helper-class for the Command implementation which stores the command and condition function objects
RTT::internal::DataSourceStorageImpl< 0, DataType >When no arguments are to be stored
RTT::internal::DataSourceStorageImpl< 1, DataType >Stores one data source
RTT::scripting::DataSourceTimeA internal::DataSource which returns the time elapsed since the last reset in Seconds
RTT::internal::DataSourceTypeInfo< T >Every DataSource of type T has a type info class which it can ask type information
RTT::internal::DataSourceTypeInfo< const T & >These specialisations only serve to find out if a type T is a pointer, or reference, or..
RTT::internal::DataSourceTypeInfo< types::carray< T > >Specialisation for a types::carray<T> type info object
RTT::internal::DataSourceTypeInfo< UnknownType >This class offers the default implementation of type information for an unknown type
RTT::internal::DataSourceTypeInfo< void >(void) is a special case
RTT::marsh::DemarshallInterfaceAn interface for extracting properties from a format
RTT::dev::DigitalInInterfaceA class representing a Digital Input device from which a maximum of 32 bits can be read at once
RTT::dev::DigitalInputA class representing a switch which can be on or off
RTT::dev::DigitalOutInterfaceA class representing a Digital Output device which can read or write a maximum of 32 bits at once
RTT::dev::DigitalOutputA DigitalOut represents any on/off output
RTT::mqueue::DispatcherThis object waits on a set of open message queue file descriptors and signals the channel that has received new data
RTT::base::DisposableInterfaceAn object that is executable and is freed after execution
RTT::dev::DriveInterfaceA Drive Object controls a single axis
RTT::internal::DSRStore< T >Analogous to RStore, but specific for DataSourceStorage
RTT::scripting::EdgeConditionThis class represents a conditional branch in a program tree
RTT::types::EmptySendHandleThis is a placeholder for scripting purposes
RTT::types::EmptyTypeInfoEmpty implementation of TypeInfo interface
RTT::dev::EncoderInterfaceThe most generic interface to a position/turn counter, for encoding positions
RTT::types::EnumTypeInfo< T >Type information for Enum types for which they are convertible to int
RTT::scripting::EvalCommandEvaluates a internal::DataSource<bool> in a command
RTT::scripting::EvalCommandResultThe result of a command which evaluates a boolean DataSource
RTT::base::ExecutableInterfaceObjects that implement this interface are to be executed in the ExecutionEngine
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::scripting::ExpressionParserHow we parse: this parser works like a stack-based RPN calculator
RTT::scripting::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::scripting::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::extras::FileDescriptorActivityAn activity which is triggered by the availability of data on a set of file descriptors
RTT::PropertyBag::FindPropType< T >A function object for finding a Property by name and type
RTT::scripting::FunctionFactoryA Factory which delivers operations which execute a FunctionGraph in an engine
RTT::scripting::FunctionGraphThis class represents a function
RTT::scripting::FunctionGraphBuilderThis class builds a program consisting of data contained in a program graph tree, based on the Boost Graph Library
RTT::internal::FusedFunctorDataSource< Signature, Enable >A DataSource that calls a functor of signature Signature which gets its arguments from other data sources
RTT::internal::FusedMCallDataSource< Signature >A DataSource that calls a method which gets its arguments from other data sources
RTT::internal::FusedMCollectDataSource< Signature >A DataSource that collects the result of an asynchronous method which store its results in other data sources
RTT::internal::FusedMSendDataSource< Signature >A DataSource that sends a method which gets its arguments from other data sources
RTT::internal::FusedMSignal< Signature >A Factory that reacts to a Signal by writing the arguments in data sources and calling an action
RTT::internal::GenerateDataSourceA function object which returns a vector of DataSources
RTT::internal::GetArgument< Seq, Data, Enable >Helper class for extracting the bare pointer from a shared_ptr data source
RTT::internal::GetArgument< Seq, Data, typename boost::enable_if< is_pure_reference< Data > >::type >In this case, Data is a pure reference and the first element of Seq is an AssignableDataSource
RTT::internal::GetSignature< FunctionT >Returns a function signature from a C or C++ member function pointer type
RTT::internal::GetSignatureDS< FunctionT >Returns a function signature from a C or C++ member function pointer type, suitable for DS operations
RTT::internal::GlobalEngineA process-wide execution engine that processes every asynchronous operation that is not being processed by a TaskContext
RTT::internal::GlobalServiceA process-wide services that hosts services not local to a single component
RTT::types::GlobalsRepositoryAn RTT::ConfigurationInterface for holding global variables
std::greater< const _Tp & >One of the comparison functors
RTT::HandleThe Handle holds the information, and allows manipulation, of a connection between a internal::Signal Handler function and the Signal 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::os::InitFunctionUse this to register a global init function to the StartStopManager
RTT::InputPort< T >A component's data input port
RTT::base::InputPortInterfaceThe base class of the InputPort
RTT::internal::InputPortSource< T >This class represents a read port using the data source interface
RTT::invalid_handle_exceptionException thrown when a factory is requested to create an object with an invalid SendHandle
RTT::internal::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::internal::InvokerBase< F >This is the base class that defines the interface of all invocable method implementations
RTT::extras::IRQActivityAn activity which is triggered by an IRQ edge
RTT::internal::is_arg_return< Arg >This helper struct is required to filter out the AStore elements that don't need to be returned to the user when collect or return is called
RTT::internal::is_out_arg< Arg >Outargs are of type AStore and contain a pure reference
RTT::internal::LateConstReferenceDataSource< T >A DataSource which is used to manipulate a const reference to an external value, by means of a pointer, which can be set after the data source was created
RTT::internal::LateReferenceDataSource< T >A DataSource which is used to manipulate a reference to an external value, by means of a pointer, which can be set after the data source was created
std::less< const _Tp & >One of the comparison functors
RTT::internal::List< T >This object represents the default queue implementation used by Orocos objects
RTT::internal::ListLocked< T >A simple lock-based list implementation to append or erase data of type T
RTT::internal::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::internal::LocalConnIDRepresents a local connection created by the ConnFactory
RTT::internal::LocalOperationCaller< FunctionT >A method which executes a local function
RTT::internal::LocalOperationCallerImpl< FunctionT >Implements call, send, collect, collectIfDone for all function arities
RTT::internal::LockedQueue< T >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::MarshallingService requester to load and save properties of a TaskContext
RTT::marsh::MarshallingServiceService which loads and saves properties of a TaskContext
RTT::marsh::MarshallInterfaceA MarshallInterface converts Property objects to a (file/text) format
RTT::mqueue::MQChannelElement< T >Implements the a ChannelElement using message queues
RTT::mqueue::MQLibPluginThe CORBA transport plugin
RTT::mqueue::MQSendRecvImplements the sending/receiving of mqueue messages
RTT::mqueue::MQTemplateProtocol< T >For each transportable type T, specify the conversion functions
RTT::extras::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::internal::MWSRQueue< T >This object represents the default Multi-Writer, Single-Reader queue implementation used by Orocos objects
RTT::internal::NA< T >This class is used to return a 'default' value when no value is available ('Not Available')
RTT::internal::NA< void >Specialisation to return a void
RTT::dev::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::dev::NameServer< _ValueType >A nameserver for Orocos Device classes
RTT::dev::NameServerRegistrator< T >Utility class to register a given object with a nameserver, and deregister upon destruction
RTT::internal::NArityDataSource< function >A generic N-arity composite DataSource
RTT::no_asynchronous_operation_exceptionException thrown when a factory is requested to produce an asynchronous object while it is not available for that operation
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::corba::NonExistingDataSourceGets thrown by the constructor of DataSourceProxy or ValueDataSourceProxy when invalid service or property/attribute was given
std::not_equal_to< const _Tp & >One of the comparison functors
RTT::Operation< Signature >The operation ties a C or C++ function into a component interface
RTT::base::OperationBaseThis base class serves as a template-less handle for operation objects and also stores the name and documentation of an operation
RTT::OperationCaller< SignatureT >A OperationCaller serves as a placeholder (aka 'proxy') for a remote Operation
RTT::base::OperationCallerBase< F >The base class for all method implementations
RTT::base::OperationCallerBaseInvokerAn invoker can be given an implementation and is identified by a name
RTT::internal::OperationCallerBinder< F >Very simple factory class to bind a member function to an object pointer and leave the arguments open
RTT::internal::OperationCallerCA template-less manager for OperationCaller calls
RTT::base::OperationCallerInterfaceThe interface class for operation callers
RTT::corba::OperationCallerProxyMirrors a remote operation caller in a ServiceRequestor
RTT::OperationInterfaceHolds all exported operations of a component and is able to produce callers for these operations
RTT::OperationInterfacePartThis class defines the interface for creating operation objects without using C++ templates
RTT::internal::OperationInterfacePartFused< Signature >OperationInterfacePart implementation that uses boost::fusion to produce items
RTT::internal::OperationInterfacePartFusedDS< Signature, ObjT >OperationInterfacePart implementation that uses boost::fusion to produce items
RTT::SendHandleC::E::OperationKeeperThis is a custom deleter that blocks on an asynchronous operation
RTT::types::OperatorRepositoryThis class builds on upon construction all expression operators known to Orocos
RTT::corba::OrbRunnerClass which runs an orb in an Orocos thread
oro_atomic_tStructure that contains an int for atomic operations
RTT::OutputPort< T >A component's data output port
RTT::base::OutputPortInterfaceThe base class of each OutputPort
RTT::parse_exceptionThis is the uppermost exception class in the parser system
RTT::scripting::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::scripting::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::scripting::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::scripting::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::scripting::ParsedStateMachineState machine created by the scripting engine which represents a parsed state machine
RTT::scripting::ParserThis class is the public interface to the Orocos Program Parser Framework
RTT::internal::PartDataSource< T >A DataSource which is used to manipulate a reference to a part of a data source
RTT::internal::PartDataSource< types::carray< T > >Partial specialisation of PartDataSource for carray<T> types
RTT::scripting::PeerParserGet the peer and object from an invocation path like a.b.c.d()
RTT::extras::PeriodicActivityA PeriodicActivity is the general implementation of a Activity which has (realtime) periodic constraints
RTT::plugin::PluginLoaderLoads plugins found on the filesystem and keeps track of found plugins, typekits and services
RTT::base::PortInterfaceThe base class of every data flow port
RTT::types::PrimitiveSequenceTypeInfo< T, has_ostream >New-style SequenceTypeInfo which offers type info for sequences which can NOT be sent over flow ports
RTT::types::PrimitiveTypeInfo< T, use_ostream >This template class allows primitive types, which are not sent over ports, to be added to Orocos
RTT::os::printstreamThe printstream is a stream for printing characters to the terminal window
RTT::scripting::program_load_exceptionThis exception is thrown when a program or state machine could not be loaded into a ProgramProcessor or StateMachineProcessor
RTT::scripting::program_unload_exceptionThis exception is thrown when a program or state machine could not be unloaded into a ProgramProcessor or StateMachineProcessor
RTT::scripting::ProgramGraphParserA Parser for Orocos Program Scripts
RTT::scripting::ProgramInterfaceA Program represents a collection of instructions that can be stepwise executed
RTT::scripting::ProgramServiceThis class represents a program as an Service 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::marsh::PropertyBagIntrospectorThis class fills up a given bag with the results of an introspection
RTT::base::PropertyBagVisitorA simple introspection interface to visit PropertyBags
RTT::base::PropertyBaseBase class for all properties
RTT::marsh::PropertyDemarshallerThe default Orocos demarshaller for extracting properties and property bags from a property file
RTT::base::PropertyIntrospectionAn interface which all classes which wish to visit a Property should implement
RTT::marsh::PropertyLoaderLoad and save property files to a Service's PropertyBag
RTT::marsh::PropertyMarshallerA class for writing a property or propertybag into file
RTT::scripting::PropertyParserGet the property and bag from an invocation path like bag.subbag.prop
RTT::extras::IRQActivity::ProviderIf this interface is derived from one of the TaskContext objects which are executed by this activity, then the activity can auto-configure itself (i.e
RTT::dev::PulseTrainGeneratorInterfaceA generic interface to a pulsetraingenerator for simulation of encoder like behaviour
RTT::internal::Queue< T >This object represents the default Multi-Writer/Multi-Reader queue implementation used by Orocos objects
RTT::extras::ReadOnlyPointer< T >Smart pointer that allows safe sharing of data between multiple threads
RTT::types::RealTimeTypekitPluginThis interface defines the types of the realTime package
RTT::internal::ReferenceObject that may receive a reference to some data by means of a pointer or data source
RTT::internal::ReferenceDataSource< T >A DataSource which is used to manipulate a reference to an external value
RTT::corba::RemoteChannelElement< T >Implements the CRemoteChannelElement of the CORBA IDL interface
RTT::corba::RemoteConnIDRepresents a connection to a remote CORBA port
RTT::corba::RemoteInputPortProxy for a remote input port
RTT::internal::RemoteOperationCaller< OperationCallerT >A OperationCaller implementation which delegates C++ to datasource conversions when C++ code tries to call remote methods, only available in an OperationInterfacePart, and not through an OperationBase
RTT::internal::RemoteOperationCallerImpl< OperationCallerT >A OperationCaller implementation which executes a remote function which is encapsulated in a OperationCallerC and SendHandleC object
RTT::corba::RemoteOutputPortProxy for a remote output port
RTT::corba::RemotePort< PortClass >Contains the common CORBA management code for proxy port objects representing ports available through CORBA
RTT::internal::ReturnBase< F >This is the base class that defines the interface of returning data from method invocations
RTT::internal::RStore< T >Store a return value which may be a void, reference, const reference or any other type
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::types::RTStringTypeInfoStandard string specialisation that removes decomposition
RTT::base::RunnableInterfaceA class for running a certain piece of code in a thread
RTT::ScopedHandleA scoped connection Handle of a (connected) slot which disconnects a slot from a signal in its destructor
RTT::ScriptingThe method interface of the scripting plugin
RTT::scripting::ScriptingServiceThis interface allows to load program scripts and state machines and allows execution of code
RTT::scripting::ScriptParserParsers and executes any RTT script you throw at it
RTT::scripting::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::SendHandle< Signature >The SendHandle is used to collect the result values of an asynchronous invocation
RTT::scripting::SendHandleAliasKeeps track of a DataSource which has a SendHandle and the factory for creating the collect functions associated with that handle
RTT::internal::SendHandleCA template-less SendHandle manager
RTT::dev::SensorInterface< SensorData >An interface that describes a general sensor You can read a value/structure
RTT::types::sequence_constructor_datasource< T >Helper DataSource for constructing sequences with a variable number of parameters
RTT::types::sequence_ctor< T >Sequence constructor which takes the number of elements in the sequence
RTT::types::sequence_ctor2< T >Constructs a sequence from the number of elements and a prototype element for these elements
RTT::types::sequence_varargs_ctor< T >See NArityDataSource which requires a function object like this one
RTT::types::SequenceBuilder< T >Constructs an sequence with n elements, which are given upon construction time
RTT::types::SequenceTypeInfo< T, has_ostream >Old-style SequenceTypeInfo which offers type info for sequences which can be sent over flow ports
RTT::types::SequenceTypeInfoBase< T >Template for data types that are C++ STL Sequences with operator[], size() and capacity() methods
RTT::extras::SequentialActivityThe default, thread-less activity for any newly created TaskContext
RTT::ServiceThis class allows storage and retrieval of operations, attributes and properties provided by a component
RTT::ServiceRequesterAn object that expresses you wish to use a service
RTT::internal::Signal< Signature, TSlotFunction >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::internal::SignalBaseThe base signal class which stores connection objects
RTT::internal::SimpleConnIDA simplistic id that is only same with its own clones (and clones of clones)
RTT::extras::SimulationActivityA SimulationActivity is a PeriodicActivity which is used for simulation
RTT::extras::SimulationThreadThis thread is the simulated real-time periodic thread in the Orocos system
RTT::extras::SlaveActivityAn base::ActivityInterface implementation which executes 'step' upon the invocation of 'execute()', which is called by another Activity ('master')
RTT::os::StartStopManagerThis manager starts and stops all globally registered start/stop functions, without a particular order
RTT::scripting::StateDescriptionThis class represents a state with all actions stored in an external program
RTT::scripting::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::scripting::StateInterfaceA State contains an entry, run, handle and exit program
RTT::scripting::StateMachineA hierarchical StateMachine which is loaded in the Program Processor
RTT::scripting::StateMachineServiceThis class represents a stateMachine as a Service in the Orocos TaskContext system
RTT::scripting::StatementProcessorThis class parses and executes a single scripting statement
RTT::scripting::ProgramInterface::StatusPlaceholder of the ProgramStatus
RTT::scripting::StateMachine::StatusEnumerates all possible state machine statuses
RTT::types::StdPrimitiveTypeInfo< T >Type information for standard C types or structs of which no introspection is required and NOT used on data ports
RTT::types::StdStringTypeInfoStandard string specialisation that removes decomposition
RTT::types::StdTypeInfo< T >Type information for standard C types or structs of which no introspection is required
RTT::types::stdvector_varargs_ctor< T >See internal::NArityDataSource which requires a function object like this one
RTT::types::StdVectorBuilder< T >Constructs an array with n elements, which are given upon construction time
RTT::types::StdVectorTypeInfoThis class tells Orocos how to handle std::vector<double>
RTT::os::streambufsA base class for all stream buffer operations
RTT::internal::StreamConnIDRepresents a Stream connection created by the ConnFactory
RTT::marsh::StreamProcessor< Stream >An interface for setting and getting a stream object
RTT::os::stringbufsA streambufs implementation based on strings
RTT::os::stringstreamsStringstreams, are not guaranteed to be hard realtime
RTT::types::StructTypeInfo< T, has_ostream >Type Information for data types that are structs, ie all user data types fall in this category
RTT::internal::SynchronousOperationInterfacePartFused< Signature >OperationInterfacePart implementation that only provides synchronous access to an operation
RTT::scripting::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::TaskContextThe TaskContext is the C++ representation of an Orocos component
RTT::corba::TaskContextFactoryUse this class to create Corba TaskContext proxies, without including any CORBA header
RTT::corba::TaskContextProxyThis class manages the access of remote TaskContext Corba Servers and a Corba Object Request Broker (Orb) which connects to these servers
RTT::corba::TaskContextServerThis class manages the creation of TaskContext Corba Servers and a Corba Object Request Broker (Orb) which executes the servers
RTT::base::TaskCoreThe minimal Orocos task
RTT::types::TemplateConstructor< S >The constructor classes allow to define type constructors or type conversions (convert type B from type A)
RTT::types::TemplateTypeInfo< T, use_ostream >This template class allows user types to be used in all Orocos primitives
RTT::os::ThreadA Thread object executes user code in its own thread
RTT::os::ThreadInterfaceA thread which is being run
RTT::os::TimerThis class allows to define a timer object which can be armed in single shot and periodic mode
RTT::extras::TimerThreadThis Periodic Thread is meant for executing a PeriodicActivity object periodically
RTT::os::TimeServiceThe TimeService is used for system-wide time keeping and conversions
RTT::marsh::TinyDemarshallerA TinyXML demarshaller for extracting properties and property bags from a Component Property File (CPF) following the CORBA 3 standard
RTT::marsh::TiXmlAttributeAn attribute is a name-value pair
RTT::marsh::TiXmlBaseTiXmlBase is a base class for every class in TinyXml
RTT::marsh::TiXmlCommentAn XML comment
RTT::marsh::TiXmlDeclarationIn correct XML the declaration is the first entry in the file
RTT::marsh::TiXmlDocumentAlways the top level node
RTT::marsh::TiXmlElementThe element is a container class
RTT::marsh::TiXmlHandleA TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing
RTT::marsh::TiXmlNodeThe parent class for everything in the Document Object Model
RTT::marsh::TiXmlTextXML text
RTT::marsh::TiXmlUnknownAny tag that tinyXml doesn't recognize is saved as an unknown
RTT::types::TransportPluginA class which registers TypeTransporter instances to types
RTT::scripting::TryCommandA command which tries another command and stores the result in a internal::DataSource<bool>
RTT::scripting::TryCommandResultReturns the (accept/reject) status of another command
RTT::internal::TsPool< T >A multi-reader multi-writer MemoryPool implementation
RTT::types::type_discoveryThis archive is capable of decomposing objects of serialization level 1 and 2 into part data sources
RTT::types::TypeConstructorThis interface describes how constructors work
RTT::types::TypeInfoA class for representing a user type, and which can build instances of that type
RTT::types::TypeInfoGeneratorAll generator classes inherit from this object in order to allow them to be added to the TypeInfoRepository
RTT::types::TypeInfoName< T >This helper class allows only type names to be added to Orocos
RTT::types::TypeInfoRepositoryThis class contains all known types to Orocos
RTT::types::TypekitPluginThis interface defines how additional typekits are loaded into Orocos
RTT::types::TypekitRepositoryThis class allows the RTT to be extended with additional typekits (TypekitPlugin), such as for kinematics or any library foreign to Orocos
RTT::types::TypeMarshallerObjects implementing this interface have the capability to convert data sources to and from a binary representation
RTT::types::TypeTransporterThis interface defines the function a transport protocol must support in order to allow Orocos components to remotely communicate one data type
RTT::internal::UnaryDataSource< function >A DataSource which returns the return value of a unary function
RTT::types::UnaryOpUnaryOperator contains information on some unary operator that operates on one arg of a certain type
RTT::types::UnaryOperator< function >An operator which reads a single internal::DataSource and returns a modified result
RTT::internal::UnboundDataSource< BoundType >A special DataSource only to be used for if you understand the copy()/clone() semantics very well
RTT::internal::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::internal::UnPointer< F >Convert a function R (X::)(Args) to a plain function signature R(X::,Args)
RTT::internal::UpdateHelper< T >Helper to only update data sources that hold references
RTT::mqueue::binary_data_oarchive::use_array_optimizationWe provide an optimized load for all fundamental types typedef serialization::is_bitwise_serializable<mpl::_1> use_array_optimization;
RTT::mqueue::binary_data_iarchive::use_array_optimizationWe provide an optimized load for all fundamental types typedef serialization::is_bitwise_serializable<mpl::_1> use_array_optimization;
RTT::dev::NameServer< _ValueType >::value_iteratorAn Iterator to iterate over the registered objects
RTT::scripting::ValueChangeParserThis class is responsible for parsing constant definitions, variable definitions, variable change instructions, and alias definitions
RTT::internal::ValueDataSource< T >A simple, yet very useful DataSource, which keeps a value, and returns it in its get() method
RTT::corba::ValueDataSourceProxy< T >Mirrors a remote assignable value datasource
RTT::types::ValueFactoryCreates all value objects of a certain type
RTT::scripting::ValueParserA class for parsing const values
RTT::scripting::VertexNodeThis class represents elements in a program tree
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::marsh::XMLRPCDemarshallerA DemarshallInterface for the XMLRPC Protocol
RTT::marsh::XMLRPCMarshaller< output_stream >Outputs a Property or PropertyBag into a text stream in the XML-RPC format