| 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::ActionInterface | Based on the software pattern 'command', this interface allows execution of action objects |
| RTT::Activity | An Activity is an object that represents a thread |
| RTT::base::ActivityInterface | Interface to start/stop and query a Activity |
| RTT::internal::AddMember< F, Class > | The inverse of UnMember |
| RTT::Alias | This 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::AnalogInInterface | An interface for reading analog input, like for addressing a whole subdevice in comedi |
| RTT::dev::AnalogInput | A class representing an analog input channel |
| RTT::dev::AnalogOutInterface | An interface for writing analog output, like for addressing a whole subdevice in comedi |
| RTT::dev::AnalogOutput | A 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::AnyDataSource | A internal::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::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::ArgumentDescription | Description of one Argument of a Command |
| RTT::scripting::ArgumentsParser | This 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::AtomicInt | C++ 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::AttributeBase | An attribute is a minimalistic, named placeholder for data |
| RTT::dev::AxisInterface | The AxisInterface represents an axis from a control point of view |
| RTT::internal::bad_assignment | This exception is thrown if the target and source type of an assignment of a DataSource with a base::DataSourceBase differ |
| RTT::os::basic_iostreams | An IO stream based on strings |
| RTT::os::basic_istreams | An basic_istream is a stream which can be read |
| RTT::os::basic_ostreams | An basic_ostreams is a stream which can be written to |
| RTT::os::basic_streams | This is a stream class for use in limited environments |
| RTT::mqueue::binary_data_iarchive | This archive is capable of loading objects of serialization level 1 and 2 from a binary, non-portable format |
| RTT::mqueue::binary_data_oarchive | This 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::BoolTypeInfo | Write 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::BufferBase | Any 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::CalibrationInterface | A class which will calibrate a sensor |
| RTT::scripting::CallFunction | An action which calls a FunctionFraph for execution in a ExecutionEngine |
| RTT::corba::CArgumentDescription | When 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::CCallInterrupted | Is thrown if the calling or sending of an operation was interrupted |
| RTT::corba::CChannelElement | Represents the basic channel element interface for reading, writing and disconnecting a channel |
| RTT::corba::CConfigurationInterface | Exposes both attributes and properties of a service |
| RTT::corba::CDataFlowInterface | An interface to access the dataflow of a CControlTask object |
| RTT::corba::CDataFlowInterface_i | Represents 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::ChannelElementBase | In the data flow implementation, a channel is created by chaining ChannelElementBase objects |
| 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) the connection object in its destructor |
| RTT::corba::CNoCorbaTransport | Emitted during connections, when there is no CORBA transport defined for the data type of the given ports |
| RTT::corba::CNoSuchNameException | Is thrown when an operation does not exist |
| RTT::corba::CNoSuchPortException | Emitted 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::CommandComposite | Based on the software pattern 'composite', this class RTT_SCRIPTING_API allows composing command objects into one command object |
| RTT::scripting::CommandCounter | This command increments a counter when executed |
| RTT::scripting::CommandDataSource | A Command which evaluates a base::DataSourceBase and always returns true |
| RTT::scripting::CommandDataSourceBool | A Command which evaluates a internal::DataSource<bool> and returns the result of get() |
| RTT::scripting::CommandFunction | A functor with the base::ActionInterface, for the case where the functor is a bool(void) |
| RTT::scripting::CommandIllegal | A Command indicating that an error was encountered somewhere, most likely during the construction of another command |
| RTT::scripting::CommandNOP | The empty command |
| RTT::scripting::CommandString | This command displays a string when executed |
| RTT::scripting::CommonParser | This class contains some very common parser definitions |
| RTT::ComponentFactories | A 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::CompositionFactory | A factory for composing/decomposing and converting types to a form suitable for persistent storage, such as an XML file |
| RTT::os::Condition | An object oriented wrapper around a condition variable |
| RTT::scripting::ConditionBinaryCompositeAND | Compose an 'AND' function of two Conditions |
| RTT::scripting::ConditionBoolDataSource | A Condition which holds a boolean DataSource |
| RTT::scripting::ConditionBoolProperty | ConditionBoolProperty is a Condition which reads out a Property<bool> |
| RTT::scripting::ConditionCache | A conditional that evaluates and caches another Condition |
| RTT::scripting::ConditionCompare< T, compare_op > | A general compare condition |
| RTT::scripting::ConditionDSDuration | A conditional that evaluates true after a certain time (in seconds) has passed, given by a DataSource |
| RTT::scripting::ConditionDuration | A conditional that evaluates true after a certain time has passed |
| RTT::scripting::ConditionExpire | A conditional that evaluates true until a certain time has elapsed since construction or the last reset() |
| RTT::scripting::ConditionFalse | A conditional that evaluates false |
| RTT::scripting::ConditionFunction | A functor with the ConditionInterface, for the case where the functor is a bool(void) |
| RTT::scripting::ConditionInterface | This interface represents the concept of a condition which can be evaluated and return true or false |
| RTT::scripting::ConditionInvert | A conditional that evaluates to the inverse of another Condition |
| RTT::scripting::ConditionOnce | A conditional that evaluates the first time true and afterwards always false (or vice versa) |
| RTT::scripting::ConditionParser | This is a class containing a parse function for conditions |
| RTT::scripting::ConditionTrue | A conditional that evaluates true |
| RTT::ConfigurationInterface | A class for keeping track of Attribute, Constant and Property objects of a TaskContext |
| RTT::internal::ConnectionBase | A connection 'memorises' the connection between an event and an event handler function |
| RTT::internal::ConnectionManager | Manages connections between ports |
| RTT::internal::ConnFactory | This class provides the basic tools to create channels that represent connections between two ports |
| RTT::internal::ConnID | This 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::ConnPolicy | A 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::ConstructorParser | Parses type constructor syntax |
| RTT::corba::COperationInterface | Exposes the operations this service offers |
| RTT::corba::CorbaDispatcher | This object sends over data flow messages from local buffers to a remote channel element |
| RTT::corba::CorbaFallBackProtocol | This protocol is used for all types which did not get a protocol |
| RTT::corba::CorbaLibPlugin | The CORBA transport plugin |
| CorbaOperationCallerCall | Calls a CORBA method |
| CorbaOperationCallerCollect | Collects a CORBA method |
| RTT::corba::CorbaOperationCallerFactory | A local factory for creating remote Corba methods |
| RTT::corba::CorbaTemplateProtocol< T > | For each transportable type T, specify the conversion functions |
| RTT::corba::CorbaTypeTransporter | Extends 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_helper | Helper to convert a single data source base to a DataSource or AssignableDataSource |
| RTT::corba::CRemoteChannelElement | The advanced channel element interface, used by Orocos to relay over-CORBA data flow connections |
| RTT::corba::CRemoteChannelElement_i | Base class for CORBA channel servers |
| RTT::corba::CSendHandle | A handler object that allows us to collect the results of a send |
| RTT::corba::CService | An Orocos Service which hosts operations, attributes and properties |
| RTT::corba::CServiceRequester | An Orocos Required Service |
| RTT::corba::CTaskContext | A CTaskContext is the main entry point of a distributed component and maps to a RTT::TaskContext |
| RTT::corba::CWrongArgumentException | Is thrown when a wrong argument number is queried |
| RTT::corba::CWrongNumbArgException | Is thrown when a wrong number of arguments is provided |
| RTT::corba::CWrongTypeArgException | Is thrown when a wrong type of arguments is provided |
| RTT::Logger::D | This hidden struct stores all data structures required for logging |
| RTT::scripting::DataCallParser | This parser parses a call of the form "a.b( arg1, arg2, ..., argN )" |
| RTT::DataFlowInterface | The 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::DataSourceBase | The base class for all internal data representations |
| RTT::internal::DataSourceCommand | A class that wraps a Command in a internal::DataSource<bool> interface |
| RTT::scripting::DataSourceCondition | A 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::DataSourceTime | A 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::DemarshallInterface | An interface for extracting properties from a format |
| RTT::dev::DigitalInInterface | A class representing a Digital Input device from which a maximum of 32 bits can be read at once |
| RTT::dev::DigitalInput | A class representing a switch which can be on or off |
| RTT::dev::DigitalOutInterface | A class representing a Digital Output device which can read or write a maximum of 32 bits at once |
| RTT::dev::DigitalOutput | A DigitalOut represents any on/off output |
| RTT::mqueue::Dispatcher | This object waits on a set of open message queue file descriptors and signals the channel that has received new data |
| RTT::base::DisposableInterface | An object that is executable and is freed after execution |
| RTT::dev::DriveInterface | A Drive Object controls a single axis |
| RTT::internal::DSRStore< T > | Analogous to RStore, but specific for DataSourceStorage |
| RTT::scripting::EdgeCondition | This class represents a conditional branch in a program tree |
| RTT::types::EmptySendHandle | This is a placeholder for scripting purposes |
| RTT::types::EmptyTypeInfo | Empty implementation of TypeInfo interface |
| RTT::dev::EncoderInterface | The 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::EvalCommand | Evaluates a internal::DataSource<bool> in a command |
| RTT::scripting::EvalCommandResult | The result of a command which evaluates a boolean DataSource |
| RTT::base::ExecutableInterface | Objects that implement this interface are to be executed in the ExecutionEngine |
| 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::scripting::ExpressionParser | How we parse: this parser works like a stack-based RPN calculator |
| RTT::scripting::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::scripting::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::extras::FileDescriptorActivity | An 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::FunctionFactory | A Factory which delivers operations which execute a FunctionGraph in an engine |
| RTT::scripting::FunctionGraph | This class represents a function |
| RTT::scripting::FunctionGraphBuilder | This 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::GenerateDataSource | A 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::GlobalEngine | A process-wide execution engine that processes every asynchronous operation that is not being processed by a TaskContext |
| RTT::internal::GlobalService | A process-wide services that hosts services not local to a single component |
| RTT::types::GlobalsRepository | An RTT::ConfigurationInterface for holding global variables |
| std::greater< const _Tp & > | One of the comparison functors |
| RTT::Handle | The Handle holds the information, and allows manipulation, of a connection between a internal::Signal Handler function and the Signal 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::os::InitFunction | Use this to register a global init function to the StartStopManager |
| RTT::InputPort< T > | A component's data input port |
| RTT::base::InputPortInterface | The base class of the InputPort |
| RTT::internal::InputPortSource< T > | This class represents a read port using the data source interface |
| RTT::invalid_handle_exception | Exception 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::IRQActivity | An 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::LocalConnID | Represents 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::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::Marshalling | Service requester to load and save properties of a TaskContext |
| RTT::marsh::MarshallingService | Service which loads and saves properties of a TaskContext |
| RTT::marsh::MarshallInterface | A MarshallInterface converts Property objects to a (file/text) format |
| RTT::mqueue::MQChannelElement< T > | Implements the a ChannelElement using message queues |
| RTT::mqueue::MQLibPlugin | The CORBA transport plugin |
| RTT::mqueue::MQSendRecv | Implements 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::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::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_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::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_exception | Exception thrown when a factory is requested to produce an asynchronous object while it is not available for that operation |
| 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::corba::NonExistingDataSource | Gets 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::OperationBase | This 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::OperationCallerBaseInvoker | An 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::OperationCallerC | A template-less manager for OperationCaller calls |
| RTT::base::OperationCallerInterface | The interface class for operation callers |
| RTT::corba::OperationCallerProxy | Mirrors a remote operation caller in a ServiceRequestor |
| RTT::OperationInterface | Holds all exported operations of a component and is able to produce callers for these operations |
| RTT::OperationInterfacePart | This 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::OperationKeeper | This is a custom deleter that blocks on an asynchronous operation |
| RTT::types::OperatorRepository | This class builds on upon construction all expression operators known to Orocos |
| RTT::corba::OrbRunner | Class which runs an orb in an Orocos thread |
| oro_atomic_t | Structure that contains an int for atomic operations |
| RTT::OutputPort< T > | A component's data output port |
| RTT::base::OutputPortInterface | The base class of each OutputPort |
| RTT::parse_exception | This is the uppermost exception class in the parser system |
| RTT::scripting::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::scripting::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::scripting::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::scripting::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::scripting::ParsedStateMachine | State machine created by the scripting engine which represents a parsed state machine |
| RTT::scripting::Parser | This 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::PeerParser | Get the peer and object from an invocation path like a.b.c.d() |
| RTT::extras::PeriodicActivity | A PeriodicActivity is the general implementation of a Activity which has (realtime) periodic constraints |
| RTT::plugin::PluginLoader | Loads plugins found on the filesystem and keeps track of found plugins, typekits and services |
| RTT::base::PortInterface | The 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::printstream | The printstream is a stream for printing characters to the terminal window |
| RTT::scripting::program_load_exception | This exception is thrown when a program or state machine could not be loaded into a ProgramProcessor or StateMachineProcessor |
| RTT::scripting::program_unload_exception | This exception is thrown when a program or state machine could not be unloaded into a ProgramProcessor or StateMachineProcessor |
| RTT::scripting::ProgramGraphParser | A Parser for Orocos Program Scripts |
| RTT::scripting::ProgramInterface | A Program represents a collection of instructions that can be stepwise executed |
| RTT::scripting::ProgramService | This 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::PropertyBag | A container for holding references to properties |
| RTT::marsh::PropertyBagIntrospector | This class fills up a given bag with the results of an introspection |
| RTT::base::PropertyBagVisitor | A simple introspection interface to visit PropertyBags |
| RTT::base::PropertyBase | Base class for all properties |
| RTT::marsh::PropertyDemarshaller | The default Orocos demarshaller for extracting properties and property bags from a property file |
| RTT::base::PropertyIntrospection | An interface which all classes which wish to visit a Property should implement |
| RTT::marsh::PropertyLoader | Load and save property files to a Service's PropertyBag |
| RTT::marsh::PropertyMarshaller | A class for writing a property or propertybag into file |
| RTT::scripting::PropertyParser | Get the property and bag from an invocation path like bag.subbag.prop |
| RTT::extras::IRQActivity::Provider | If 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::PulseTrainGeneratorInterface | A 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::RealTimeTypekitPlugin | This interface defines the types of the realTime package |
| RTT::internal::Reference | Object 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::RemoteConnID | Represents a connection to a remote CORBA port |
| RTT::corba::RemoteInputPort | Proxy 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::RemoteOutputPort | Proxy 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::RTStringTypeInfo | Standard string specialisation that removes decomposition |
| RTT::base::RunnableInterface | A class for running a certain piece of code in a thread |
| RTT::ScopedHandle | A scoped connection Handle of a (connected) slot which disconnects a slot from a signal in its destructor |
| RTT::Scripting | The method interface of the scripting plugin |
| RTT::scripting::ScriptingService | This interface allows to load program scripts and state machines and allows execution of code |
| RTT::scripting::ScriptParser | Parsers and executes any RTT script you throw at it |
| RTT::scripting::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::SendHandle< Signature > | The SendHandle is used to collect the result values of an asynchronous invocation |
| RTT::scripting::SendHandleAlias | Keeps track of a DataSource which has a SendHandle and the factory for creating the collect functions associated with that handle |
| RTT::internal::SendHandleC | A 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::SequentialActivity | The default, thread-less activity for any newly created TaskContext |
| RTT::Service | This class allows storage and retrieval of operations, attributes and properties provided by a component |
| RTT::ServiceRequester | An 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::SignalBase | The base signal class which stores connection objects |
| RTT::internal::SimpleConnID | A simplistic id that is only same with its own clones (and clones of clones) |
| RTT::extras::SimulationActivity | A SimulationActivity is a PeriodicActivity which is used for simulation |
| RTT::extras::SimulationThread | This thread is the simulated real-time periodic thread in the Orocos system |
| RTT::extras::SlaveActivity | An base::ActivityInterface implementation which executes 'step' upon the invocation of 'execute()', which is called by another Activity ('master') |
| RTT::os::StartStopManager | This manager starts and stops all globally registered start/stop functions, without a particular order |
| RTT::scripting::StateDescription | This class represents a state with all actions stored in an external program |
| RTT::scripting::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::scripting::StateInterface | A State contains an entry, run, handle and exit program |
| RTT::scripting::StateMachine | A hierarchical StateMachine which is loaded in the Program Processor |
| RTT::scripting::StateMachineService | This class represents a stateMachine as a Service in the Orocos TaskContext system |
| RTT::scripting::StatementProcessor | This class parses and executes a single scripting statement |
| RTT::scripting::ProgramInterface::Status | Placeholder of the ProgramStatus |
| RTT::scripting::StateMachine::Status | Enumerates 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::StdStringTypeInfo | Standard 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::StdVectorTypeInfo | This class tells Orocos how to handle std::vector<double> |
| RTT::os::streambufs | A base class for all stream buffer operations |
| RTT::internal::StreamConnID | Represents a Stream connection created by the ConnFactory |
| RTT::marsh::StreamProcessor< Stream > | An interface for setting and getting a stream object |
| RTT::os::stringbufs | A streambufs implementation based on strings |
| RTT::os::stringstreams | Stringstreams, 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_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::TaskContext | The TaskContext is the C++ representation of an Orocos component |
| RTT::corba::TaskContextFactory | Use this class to create Corba TaskContext proxies, without including any CORBA header |
| RTT::corba::TaskContextProxy | This class manages the access of remote TaskContext Corba Servers and a Corba Object Request Broker (Orb) which connects to these servers |
| RTT::corba::TaskContextServer | This class manages the creation of TaskContext Corba Servers and a Corba Object Request Broker (Orb) which executes the servers |
| RTT::base::TaskCore | The 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::Thread | A Thread object executes user code in its own thread |
| RTT::os::ThreadInterface | A thread which is being run |
| RTT::os::Timer | This class allows to define a timer object which can be armed in single shot and periodic mode |
| RTT::extras::TimerThread | This Periodic Thread is meant for executing a PeriodicActivity object periodically |
| RTT::os::TimeService | The TimeService is used for system-wide time keeping and conversions |
| RTT::marsh::TinyDemarshaller | A TinyXML demarshaller for extracting properties and property bags from a Component Property File (CPF) following the CORBA 3 standard |
| RTT::marsh::TiXmlAttribute | An attribute is a name-value pair |
| RTT::marsh::TiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| RTT::marsh::TiXmlComment | An XML comment |
| RTT::marsh::TiXmlDeclaration | In correct XML the declaration is the first entry in the file |
| RTT::marsh::TiXmlDocument | Always the top level node |
| RTT::marsh::TiXmlElement | The element is a container class |
| RTT::marsh::TiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| RTT::marsh::TiXmlNode | The parent class for everything in the Document Object Model |
| RTT::marsh::TiXmlText | XML text |
| RTT::marsh::TiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| RTT::types::TransportPlugin | A class which registers TypeTransporter instances to types |
| RTT::scripting::TryCommand | A command which tries another command and stores the result in a internal::DataSource<bool> |
| RTT::scripting::TryCommandResult | Returns the (accept/reject) status of another command |
| RTT::internal::TsPool< T > | A multi-reader multi-writer MemoryPool implementation |
| RTT::types::type_discovery | This archive is capable of decomposing objects of serialization level 1 and 2 into part data sources |
| RTT::types::TypeConstructor | This interface describes how constructors work |
| RTT::types::TypeInfo | A class for representing a user type, and which can build instances of that type |
| RTT::types::TypeInfoGenerator | All 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::TypeInfoRepository | This class contains all known types to Orocos |
| RTT::types::TypekitPlugin | This interface defines how additional typekits are loaded into Orocos |
| RTT::types::TypekitRepository | This class allows the RTT to be extended with additional typekits (TypekitPlugin), such as for kinematics or any library foreign to Orocos |
| RTT::types::TypeMarshaller | Objects implementing this interface have the capability to convert data sources to and from a binary representation |
| RTT::types::TypeTransporter | This 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::UnaryOp | UnaryOperator 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_optimization | We 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_optimization | We provide an optimized load for all fundamental types typedef serialization::is_bitwise_serializable<mpl::_1> use_array_optimization; |
| RTT::dev::NameServer< _ValueType >::value_iterator | An Iterator to iterate over the registered objects |
| RTT::scripting::ValueChangeParser | This 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::ValueFactory | Creates all value objects of a certain type |
| RTT::scripting::ValueParser | A class for parsing const values |
| RTT::scripting::VertexNode | This class represents elements in a program tree |
| 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::marsh::XMLRPCDemarshaller | A DemarshallInterface for the XMLRPC Protocol |
| RTT::marsh::XMLRPCMarshaller< output_stream > | Outputs a Property or PropertyBag into a text stream in the XML-RPC format |
