| ▼Nboost | |
| ▼NRTT | Contains TaskContext, Activity, OperationCaller, Operation, Property, InputPort, OutputPort, Attribute |
| ►Nbase | Base classes of RTT classes |
| CActionInterface | Based on the software pattern 'command', this interface allows execution of action objects |
| CActivityInterface | Interface to start/stop and query a Activity |
| CAttributeBase | An attribute is a minimalistic, named placeholder for data |
| CBuffer | This object represents the default thread-safe buffer implementation used by Orocos objects |
| CBufferBase | Any Buffer has a capacity, size and can be empty or full |
| CBufferInterface | A Buffer is an object which is used to store (Push) and retrieve (Pop) values from |
| CBufferLocked | Implements a very simple blocking thread-safe buffer, using mutexes (locks) |
| CBufferLockFree | A Lock-free buffer implementation to read and write data of type T in a FIFO way |
| CBufferUnSync | Implements a not threadsafe buffer |
| CChannelElement | A typed version of ChannelElementBase |
| CChannelElementBase | In the data flow implementation, a channel is created by chaining ChannelElementBase objects |
| CDataObject | This object represents the default thread-safe data object implementation used by Orocos objects |
| CDataObjectInterface | A DataObjectInterface implements multi-threaded read/write solutions |
| CDataObjectLocked | A class which provides locked/protected access to one typed element of data |
| CDataObjectLockFree | This DataObject is a Lock-Free implementation, such that reads and writes can happen concurrently without priority inversions |
| CDataObjectUnSync | A class which provides unprotected (not thread-safe) access to one typed element of data |
| CDataSourceBase | The base class for all internal data representations |
| CDisposableInterface | An object that is executable and is freed after execution |
| CExecutableInterface | Objects that implement this interface are to be executed in the ExecutionEngine |
| CInputPortInterface | The base class of the InputPort |
| COperationBase | This base class serves as a template-less handle for operation objects and also stores the name and documentation of an operation |
| COperationCallerBase | The base class for all method implementations |
| COperationCallerBaseInvoker | An invoker can be given an implementation and is identified by a name |
| COperationCallerInterface | The interface class for operation callers |
| COutputPortInterface | The base class of each OutputPort |
| CPortInterface | The base class of every data flow port |
| CPropertyBagVisitor | A simple introspection interface to visit PropertyBags |
| CPropertyBase | Base class for all properties |
| CPropertyIntrospection | An interface which all classes which wish to visit a Property should implement |
| CRunnableInterface | A class for running a certain piece of code in a thread |
| CTaskCore | The minimal Orocos task |
| ►Ncorba | CORBA (OmniORB/TAO) code for network data transport |
| CAnyConversion | This class converts a given application-specific type to a CORBA::Any object and vice versa |
| CAnyConversion< bool > | |
| CAnyConversion< char > | |
| CAnyConversion< ConnPolicy > | This specialisation uses the toRTT() and toCORBA functions for converting between RTT::ConnPolicy and RTT::corba::CConPolicy |
| CAnyConversion< CORBA::Any_ptr > | |
| CAnyConversion< CORBA::Any_var > | |
| CAnyConversion< double > | |
| CAnyConversion< float > | |
| CAnyConversion< int > | |
| CAnyConversion< RTT::TaskContext * > | |
| CAnyConversion< std::map< T1, T2, _Compare, _Alloc > > | 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 |
| CAnyConversion< 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 |
| CAnyConversion< std::string > | |
| CAnyConversion< std::vector< T, _Alloc > > | 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 |
| CAnyConversion< unsigned int > | |
| CAnyConversionHelper | Used for the conversion of types that are binary compatible between CORBA type and std C++ type |
| CAnyDataSource | A internal::DataSource which holds an any value and returns it in its get() method |
| CApplicationServer | A class which an provides ORB to the application process |
| CCArgumentDescription | When querying an operation for the kinds of arguments it takes, this structure is returned for each argument |
| CCCallError | |
| CCCallInterrupted | Is thrown if the calling or sending of an operation was interrupted |
| CCChannelElement | Represents the basic channel element interface for reading, writing and disconnecting a channel |
| ►CCConfigurationInterface | Exposes both attributes and properties of a service |
| CCProperty | |
| CCConnPolicy | |
| CCDataFlowInterface | An interface to access the dataflow of a CControlTask object |
| CCDataFlowInterface_i | Represents a remote data flow interface |
| CCNoCorbaTransport | Emitted during connections, when there is no CORBA transport defined for the data type of the given ports |
| CCNoSuchNameException | Is thrown when an operation does not exist |
| CCNoSuchPortException | Emitted when information is requested on a port that does not exist |
| CCOperationInterface | Exposes the operations this service offers |
| CCORBAAssignableExpression | |
| CCorbaDispatcher | This object sends over data flow messages from local buffers to a remote channel element |
| CCORBAExpression | |
| CCorbaFallBackProtocol | This protocol is used for all types which did not get a protocol |
| CCorbaLibPlugin | The CORBA transport plugin |
| CCorbaOperationCallerFactory | A local factory for creating remote Corba methods |
| CCorbaTemplateProtocol | For each transportable type T, specify the conversion functions |
| CCorbaTypeTransporter | Extends the TypeTransporter in order to allow the creation of channel elements or output halves for a given type |
| CCPortDescription | |
| CCRemoteChannelElement | The advanced channel element interface, used by Orocos to relay over-CORBA data flow connections |
| CCRemoteChannelElement_i | Base class for CORBA channel servers |
| CCSendHandle | A handler object that allows us to collect the results of a send |
| CCService | An Orocos Service which hosts operations, attributes and properties |
| CCServiceRequester | An Orocos Required Service |
| CCTaskContext | A CTaskContext is the main entry point of a distributed component and maps to a RTT::TaskContext |
| CCWrongArgumentException | Is thrown when a wrong argument number is queried |
| CCWrongNumbArgException | Is thrown when a wrong number of arguments is provided |
| CCWrongTypeArgException | Is thrown when a wrong type of arguments is provided |
| CDataSourceProxy | Mirrors a remote DataSource |
| CIllegalServer | Thrown if a server does not exist or has the wrong type |
| CNonExistingDataSource | Gets thrown by the constructor of DataSourceProxy or ValueDataSourceProxy when invalid service or property/attribute was given |
| COperationCallerProxy | Mirrors a remote operation caller in a ServiceRequestor |
| COrbRunner | Class which runs an orb in an Orocos thread |
| CPair | |
| CRemoteChannelElement | Implements the CRemoteChannelElement of the CORBA IDL interface |
| CRemoteConnID | Represents a connection to a remote CORBA port |
| CRemoteInputPort | Proxy for a remote input port |
| CRemoteOutputPort | Proxy for a remote output port |
| CRemotePort | Contains the common CORBA management code for proxy port objects representing ports available through CORBA |
| CStdException | |
| CTaskContextFactory | Use this class to create Corba TaskContext proxies, without including any CORBA header |
| CTaskContextProxy | This class manages the access of remote TaskContext Corba Servers and a Corba Object Request Broker (Orb) which connects to these servers |
| CTaskContextServer | This class manages the creation of TaskContext Corba Servers and a Corba Object Request Broker (Orb) which executes the servers |
| CValueDataSourceProxy | Mirrors a remote assignable value datasource |
| ►Ndev | |
| CAnalogInInterface | An interface for reading analog input, like for addressing a whole subdevice in comedi |
| CAnalogInput | A class representing an analog input channel |
| CAnalogOutInterface | An interface for writing analog output, like for addressing a whole subdevice in comedi |
| CAnalogOutput | A class representing an analog output channel |
| CAxisInterface | The AxisInterface represents an axis from a control point of view |
| CCalibrationInterface | A class which will calibrate a sensor |
| CDigitalInInterface | A class representing a Digital Input device from which a maximum of 32 bits can be read at once |
| CDigitalInput | A class representing a switch which can be on or off |
| CDigitalOutInterface | A class representing a Digital Output device which can read or write a maximum of 32 bits at once |
| CDigitalOutput | A DigitalOut represents any on/off output |
| CDriveInterface | A Drive Object controls a single axis |
| CEncoderInterface | The most generic interface to a position/turn counter, for encoding positions |
| CHomingInterface | |
| ►CNameServer | A nameserver for Orocos Device classes |
| Cname_iterator | An Iterator to iterate over the registered names |
| Cvalue_iterator | An Iterator to iterate over the registered objects |
| CNameServerRegistrator | Utility class to register a given object with a nameserver, and deregister upon destruction |
| CPulseTrainGeneratorInterface | A generic interface to a pulsetraingenerator for simulation of encoder like behaviour |
| CSensorInterface | An interface that describes a general sensor You can read a value/structure |
| ►Nextras | Extra classes not neccesary to build an Orocos application, but are handy in some cases, or serve as an example on how to extend the RTT |
| CFileDescriptorActivity | An activity which is triggered by the availability of data on a set of file descriptors |
| CFileDescriptorActivityInterface | An activity which is triggered by the availability of data on a set of file descriptors |
| CFileDescriptorSimulationActivity | Simulate a FileDescriptorActivity (FDA) Primarily this is designed for unit tests that are testing components that require a FDA |
| ►CIRQActivity | An activity which is triggered by an IRQ edge |
| CProvider | 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 |
| CMultiVector | A static allocated Vector |
| CPeriodicActivity | A PeriodicActivity is the general implementation of a Activity which has (realtime) periodic constraints |
| CReadOnlyPointer | Smart pointer that allows safe sharing of data between multiple threads |
| CROPtrInternal | |
| CSequentialActivity | The default, thread-less activity for any newly created TaskContext |
| CSimulationActivity | A SimulationActivity is a PeriodicActivity which is used for simulation |
| CSimulationThread | This thread is the simulated real-time periodic thread in the Orocos system |
| CSlaveActivity | An base::ActivityInterface implementation which executes 'step' upon the invocation of 'execute()', which is called by another Activity ('master') |
| CTimerThread | This Periodic Thread is meant for executing a PeriodicActivity object periodically |
| ►Ninternal | Classes which contain all implementation code for the RTT |
| ►Ndetails | |
| CGetConstRef | |
| CGetConstRef< void > | |
| CHasConst | |
| CHasConst< X const > | |
| CActionAliasAssignableDataSource | An AssignableDataSource which is used to execute an action and then return the value of another DataSource |
| CActionAliasDataSource | A DataSource which is used to execute an action and then return the value of another DataSource |
| CAddMember | The inverse of UnMember |
| Cadds3 | |
| CAliasDataSource | A DataSource which is used to mirror another datasource |
| CArgMember | A complexer variant of UnMember: Convert a member function type to a function type which contains the object as first argument |
| CArrayDataSource | A DataSource that holds a fixed size array, using the types::carray class |
| CArrayPartDataSource | A DataSource which is used to manipulate a reference to a part of a data source holding a C-style array of elements |
| CAssignableDataSource | A DataSource which has set() methods |
| CAssignCommand | This is a command that will assign the value of an expression to another at runtime |
| CAssignHelper | Helper class for avoiding assigning a bare pointer to a shared_ptr data source |
| CAssignHelper< Seq, Data, typename boost::enable_if< boost::is_pointer< typename mpl::front< Data >::type > >::type > | |
| CAStore | Store a bound argument which may be a reference, const reference or any other type |
| CAStore< T & > | |
| CAtomicMWSRQueue | Create an atomic, non-blocking Multi-Writer Single-Reader FIFO for storing a pointer T by value |
| CAtomicQueue | Create an atomic, non-blocking single ended queue (FIFO) for storing a pointer to T |
| Cbad_assignment | This exception is thrown if the target and source type of an assignment of a DataSource with a base::DataSourceBase differ |
| CBinaryDataSource | A generic binary composite DataSource |
| CBindStorage | A helper-class for the Command implementation which stores the command and collition function objects |
| CBindStorageImpl | |
| CBindStorageImpl< 0, ToBind > | When no arguments are to be stored, the implementation stores the function in a boost::function object |
| CBindStorageImpl< 1, ToBind > | Stores a pointer to a function and its arguments |
| CBindStorageImpl< 2, ToBind > | |
| CBindStorageImpl< 3, ToBind > | |
| CBindStorageImpl< 4, ToBind > | |
| CBindStorageImpl< 5, ToBind > | |
| CBindStorageImpl< 6, ToBind > | |
| CBindStorageImpl< 7, ToBind > | |
| CChannelBufferElement | A connection element that can store a fixed number of data samples |
| CChannelBufferElementBase | |
| CChannelDataElement | A connection element that stores a single data sample |
| CCollect | This struct takes the user's Function signature F and transforms it to the form required in the CollectImpl template specialisations |
| CCollectBase | This struct takes the user's Function signature F and transforms it to the form required in the CollectBaseImpl template specialisations |
| CCollectBaseImpl | The collection signature is formed by Ft, which is a transformed form of F |
| CCollectBaseImpl< 0, Ft > | |
| CCollectBaseImpl< 1, Ft > | |
| CCollectBaseImpl< 2, Ft > | |
| CCollectBaseImpl< 3, Ft > | |
| CCollectBaseImpl< 4, Ft > | |
| CCollectBaseImpl< 5, Ft > | |
| CCollectBaseImpl< 6, Ft > | |
| CCollectImpl | |
| CCollectImpl< 0, Ft, BaseImpl > | |
| CCollectImpl< 1, Ft, BaseImpl > | |
| CCollectImpl< 2, Ft, BaseImpl > | |
| CCollectImpl< 3, Ft, BaseImpl > | |
| CCollectImpl< 4, Ft, BaseImpl > | |
| CCollectImpl< 5, Ft, BaseImpl > | |
| CCollectImpl< 6, Ft, BaseImpl > | |
| CCollectSignature | Used to implement collect(), given a Function Signature |
| CCollectSignature< 0, F, ToCollect > | |
| CCollectSignature< 1, F, ToCollect > | |
| CCollectSignature< 2, F, ToCollect > | |
| CCollectSignature< 3, F, ToCollect > | |
| CCollectSignature< 4, F, ToCollect > | |
| CCollectSignature< 5, F, ToCollect > | |
| CCollectSignature< 6, F, ToCollect > | |
| CCollectType | This helper struct decomposes F and creates Ft, as required by CollectBaseImpl |
| CConnectionBase | A connection 'memorises' the connection between an event and an event handler function |
| CConnectionManager | Manages connections between ports |
| CConnFactory | This class provides the basic tools to create channels that represent connections between two ports |
| CConnID | This class is used in places where a permanent representation of a reference to a connection is needed |
| CConnInputEndpoint | This is a channel element that represents the input endpoint of a connection, i.e |
| CConnOutputEndpoint | This is a channel element that represents the output endpoint of a connection, i.e |
| CConstantDataSource | A DataSource which holds a constant value and returns it in its get() method |
| CConstReferenceDataSource | A DataSource which is used to read a const reference to an external value |
| Ccreate_sequence | This class can create three kinds of Boost Fusion Sequences |
| Ccreate_sequence_helper | Helper to convert a single data source base to a DataSource or AssignableDataSource |
| Ccreate_sequence_impl | |
| Ccreate_sequence_impl< List, 0 > | |
| Ccreate_sequence_impl< List, 1 > | |
| CDataObjectDataSource | A DataSource which is used to read a DataObject |
| CDataSource | DataSource is a base class representing a generic way to read data of type T |
| CDataSourceArgStorage | 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 |
| CDataSourceArgStorage< A & > | Partial specialisations for storing a reference |
| CDataSourceArgStorage< A const & > | Partial specialisations for storing a const reference |
| CDataSourceCommand | A class that wraps a Command in a internal::DataSource<bool> interface |
| CDataSourceResultStorage | Partial specialisations for storing a void, not a void or reference Wraps around RStore |
| CDataSourceResultStorage< R const & > | |
| CDataSourceResultStorage< void > | |
| CDataSourceStorage | A helper-class for the Command implementation which stores the command and condition function objects |
| CDataSourceStorageImpl | |
| CDataSourceStorageImpl< 0, DataType > | When no arguments are to be stored |
| CDataSourceStorageImpl< 1, DataType > | Stores one data source |
| CDataSourceStorageImpl< 2, DataType > | |
| CDataSourceStorageImpl< 3, DataType > | |
| CDataSourceStorageImpl< 4, DataType > | |
| CDataSourceStorageImpl< 5, DataType > | |
| CDataSourceStorageImpl< 6, DataType > | |
| CDataSourceStorageImpl< 7, DataType > | |
| CDataSourceTypeInfo | Every DataSource of type T has a type info class which it can ask type information |
| CDataSourceTypeInfo< const T & > | These specialisations only serve to find out if a type T is a pointer, or reference, or.. |
| CDataSourceTypeInfo< const T * > | |
| CDataSourceTypeInfo< const T > | |
| CDataSourceTypeInfo< T & > | |
| CDataSourceTypeInfo< T * > | |
| CDataSourceTypeInfo< types::carray< T > > | Specialisation for a types::carray<T> type info object |
| CDataSourceTypeInfo< UnknownType > | This class offers the default implementation of type information for an unknown type |
| CDataSourceTypeInfo< void > | (void) is a special case |
| Cdivides3 | |
| Cdivides3< int, int, int > | |
| CDSRStore | Analogous to RStore, but specific for DataSourceStorage |
| CDSRStore< T & > | |
| CDSRStore< void > | |
| CDSWrap | |
| CDSWrap< boost::intrusive_ptr< T >, typename boost::enable_if< boost::is_base_of< base::DataSourceBase, typename boost::remove_pointer< T >::type > >::type > | |
| CDSWrap< T, typename boost::enable_if< boost::is_base_of< base::DataSourceBase, typename boost::remove_pointer< T >::type > >::type > | |
| CDSWrap< T, typename boost::enable_if< boost::is_reference< T > >::type > | |
| CDSWrap< T, typename boost::enable_if< boost::is_reference_wrapper< T > >::type > | |
| CFusedFunctorDataSource | A DataSource that calls a functor of signature Signature which gets its arguments from other data sources |
| CFusedFunctorDataSource< Signature, typename boost::enable_if< is_pure_reference< typename boost::function_traits< Signature >::result_type > >::type > | |
| CFusedMCallDataSource | A DataSource that calls a method which gets its arguments from other data sources |
| CFusedMCollectDataSource | A DataSource that collects the result of an asynchronous method which store its results in other data sources |
| CFusedMSendDataSource | A DataSource that sends a method which gets its arguments from other data sources |
| CFusedMSignal | A Function object that reacts to a Signal by writing the arguments in data sources and calling an action object |
| CGenerateDataSource | A function object which returns a vector of DataSources |
| Cget_signal_impl | |
| CGetArgument | Helper class for extracting the bare pointer from a shared_ptr data source |
| CGetArgument< 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 |
| CGetPointerWrap | |
| CGetSignature | Returns a function signature from a C or C++ member function pointer type |
| CGetSignatureDS | Returns a function signature from a C or C++ member function pointer type, suitable for DS operations |
| CGlobalEngine | A process-wide execution engine that processes every asynchronous operation that is not being processed by a TaskContext |
| CGlobalService | A process-wide services that hosts services not local to a single component |
| Cidentity | |
| Cincomplete | |
| CInputPortSource | This class represents a read port using the data source interface |
| CIntrusiveStorage | |
| CInvoker | Creates an invocation object with a function signature to invoke and an implementation in which an operator(args) is available which has this signature |
| CInvokerBase | This is the base class that defines the interface of all invocable method implementations |
| CInvokerBaseImpl | A class which converts a function type signature F to a virtual send()/call() interface |
| CInvokerBaseImpl< 0, F > | |
| CInvokerBaseImpl< 1, F > | |
| CInvokerBaseImpl< 2, F > | |
| CInvokerBaseImpl< 3, F > | |
| CInvokerBaseImpl< 4, F > | |
| CInvokerBaseImpl< 5, F > | |
| CInvokerBaseImpl< 6, F > | |
| CInvokerBaseImpl< 7, F > | |
| CInvokerImpl | |
| CInvokerImpl< 0, F, BaseImpl > | |
| CInvokerImpl< 1, F, BaseImpl > | |
| CInvokerImpl< 2, F, BaseImpl > | |
| CInvokerImpl< 3, F, BaseImpl > | |
| CInvokerImpl< 4, F, BaseImpl > | |
| CInvokerImpl< 5, F, BaseImpl > | |
| CInvokerImpl< 6, F, BaseImpl > | |
| CInvokerImpl< 7, F, BaseImpl > | |
| CInvokerSignature | Used by various classes to define operator(), given a Signature |
| CInvokerSignature< 0, F, ToInvoke > | |
| CInvokerSignature< 1, F, ToInvoke > | |
| CInvokerSignature< 2, F, ToInvoke > | |
| CInvokerSignature< 3, F, ToInvoke > | |
| CInvokerSignature< 4, F, ToInvoke > | |
| CInvokerSignature< 5, F, ToInvoke > | |
| CInvokerSignature< 6, F, ToInvoke > | |
| CInvokerSignature< 7, F, ToInvoke > | |
| Cis_arg_return | 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 |
| Cis_arg_return< AStore< T & > > | |
| Cis_arg_return< AStore< T const & > > | |
| Cis_arg_return< DSRStore< T > > | |
| Cis_arg_return< DSRStore< void > > | |
| Cis_arg_return< RStore< T > > | |
| Cis_arg_return< RStore< void > > | |
| Cis_out_arg | Outargs are of type AStore and contain a pure reference |
| Cis_out_arg< AStore< T & > > | |
| Cis_out_arg< AStore< T const & > > | |
| Cis_pure_reference | |
| Cis_pure_reference< T & > | |
| Cis_pure_reference< T const & > | |
| CLateConstReferenceDataSource | 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 |
| CLateReferenceDataSource | 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 |
| CList | This object represents the default queue implementation used by Orocos objects |
| CListLocked | A simple lock-based list implementation to append or erase data of type T |
| CListLockFree | A simple lock-free list implementation to append or erase data of type T |
| CLocalConnID | Represents a local connection created by the ConnFactory |
| CLocalOperationCaller | A method which executes a local function |
| CLocalOperationCallerImpl | Implements call, send, collect, collectIfDone for all function arities |
| CLockedQueue | A lock-based queue implementation to enqueue or dequeue a pointer of type T |
| Cmultiplies3 | |
| CMWSRQueue | This object represents the default Multi-Writer, Single-Reader queue implementation used by Orocos objects |
| CNA | This class is used to return a 'default' value when no value is available ('Not Available') |
| CNA< void > | Specialisation to return a void |
| CNArityDataSource | A generic N-arity composite DataSource |
| COffsetPartDataSource | |
| COperationCallerBinder | Very simple factory class to bind a member function to an object pointer and leave the arguments open |
| COperationCallerBinderImpl | |
| COperationCallerBinderImpl< 0, F > | |
| COperationCallerBinderImpl< 1, F > | |
| COperationCallerBinderImpl< 2, F > | |
| COperationCallerBinderImpl< 3, F > | |
| COperationCallerBinderImpl< 4, F > | |
| COperationCallerBinderImpl< 5, F > | |
| COperationCallerBinderImpl< 6, F > | |
| COperationCallerBinderImpl< 7, F > | |
| COperationCallerBinderImpl< 8, F > | |
| COperationCallerBinderImpl< 9, F > | |
| ►COperationCallerC | A template-less manager for OperationCaller calls |
| CD | |
| COperationInterfacePartFused | OperationInterfacePart implementation that uses boost::fusion to produce items |
| COperationInterfacePartFusedDS | OperationInterfacePart implementation that uses boost::fusion to produce items |
| COperationInterfacePartHelper | |
| COROCOS_SIGNAL_CONNECTION_N | |
| COROCOS_SIGNAL_N | |
| CPartDataSource | A DataSource which is used to manipulate a reference to a part of a data source |
| CPartDataSource< types::carray< T > > | Partial specialisation of PartDataSource for carray<T> types |
| Cpointer_to_sixary_function | |
| Cpointer_to_ternary_function | |
| CQueue | This object represents the default Multi-Writer/Multi-Reader queue implementation used by Orocos objects |
| Creal_get_signal_impl | |
| Creal_get_signal_impl< 0, Signature, SlotFunction > | |
| Creal_get_signal_impl< 1, Signature, SlotFunction > | |
| Creal_get_signal_impl< 2, Signature, SlotFunction > | |
| Creal_get_signal_impl< 3, Signature, SlotFunction > | |
| Creal_get_signal_impl< 4, Signature, SlotFunction > | |
| Creal_get_signal_impl< 5, Signature, SlotFunction > | |
| Creal_get_signal_impl< 6, Signature, SlotFunction > | |
| Creal_get_signal_impl< 7, Signature, SlotFunction > | |
| CReference | Object that may receive a reference to some data by means of a pointer or data source |
| CReferenceDataSource | A DataSource which is used to manipulate a reference to an external value |
| CRemoteOperationCaller | A OperationCaller implementation which delegates C++ to datasource conversions when C++ code tries to call remote operations, only available in an OperationInterfacePart, and not through an OperationBase |
| CRemoteOperationCallerImpl | A OperationCaller implementation which executes a remote function which is encapsulated in a OperationCallerC and SendHandleC object |
| Cremove_cr | |
| CReturn | |
| CReturnBase | This is the base class that defines the interface of returning data from method invocations |
| CReturnBaseImpl | Implementation of ret() which takes the same signature as call() |
| CReturnBaseImpl< 0, F > | |
| CReturnBaseImpl< 1, F > | |
| CReturnBaseImpl< 2, F > | |
| CReturnBaseImpl< 3, F > | |
| CReturnBaseImpl< 4, F > | |
| CReturnBaseImpl< 5, F > | |
| CReturnBaseImpl< 6, F > | |
| CReturnBaseImpl< 7, F > | |
| CReturnImpl | Implementation of ret() which takes the same signature as call() |
| CReturnImpl< 0, F, BaseImpl > | |
| CReturnImpl< 1, F, BaseImpl > | |
| CReturnImpl< 2, F, BaseImpl > | |
| CReturnImpl< 3, F, BaseImpl > | |
| CReturnImpl< 4, F, BaseImpl > | |
| CReturnImpl< 5, F, BaseImpl > | |
| CReturnImpl< 6, F, BaseImpl > | |
| CReturnImpl< 7, F, BaseImpl > | |
| CReturnSignature | Defines ret(), given a Signature |
| CReturnSignature< 0, F, ToInvoke > | |
| CReturnSignature< 1, F, ToInvoke > | |
| CReturnSignature< 2, F, ToInvoke > | |
| CReturnSignature< 3, F, ToInvoke > | |
| CReturnSignature< 4, F, ToInvoke > | |
| CReturnSignature< 5, F, ToInvoke > | |
| CReturnSignature< 6, F, ToInvoke > | |
| CReturnSignature< 7, F, ToInvoke > | |
| CRStore | Store a return value which may be a void, reference, const reference or any other type |
| CRStore< const T > | |
| CRStore< T & > | |
| CRStore< void > | |
| Cselect1st | |
| Cselect2nd | |
| ►CSendHandleC | A template-less SendHandle manager |
| CD | |
| ►CE | |
| COperationKeeper | This is a custom deleter that blocks on an asynchronous operation |
| CSignal | 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 |
| CSignalBase | The base signal class which stores connection objects |
| CSimpleConnID | A simplistic id that is only same with its own clones (and clones of clones) |
| CStreamConnID | Represents a Stream connection created by the ConnFactory |
| Csubs3 | |
| CSynchronousOperationInterfacePartFused | OperationInterfacePart implementation that only provides synchronous access to an operation |
| CTsPool | A multi-reader multi-writer MemoryPool implementation |
| CUnaryDataSource | A DataSource which returns the return value of a unary function |
| CUnboundDataSource | A special DataSource only to be used for if you understand the copy()/clone() semantics very well |
| CUnknownType | |
| CUnMember | 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 |
| CUnPointer | Convert a function R (X::)(Args) to a plain function signature R(X::,Args) |
| CUpdateHelper | Helper to only update data sources that hold references |
| CUpdateHelper< T & > | |
| CValueDataSource | A simple, yet very useful DataSource, which keeps a value, and returns it in its get() method |
| ►Nmarsh | Classes for reading/writing properties to/from file or data stream |
| CCPFMarshaller | |
| CCPFMarshaller< std::ostream > | A class for marshalling a property or propertybag into a component property description, following the CORBA 3 standard |
| CDemarshallInterface | An interface for extracting properties from a format |
| CMarshallingService | Service which loads and saves properties of a TaskContext |
| CMarshallInterface | A MarshallInterface converts Property objects to a (file/text) format |
| CPropertyBagIntrospector | This class fills up a given bag with the results of an introspection |
| CPropertyDemarshaller | The default Orocos demarshaller for extracting properties and property bags from a property file |
| CPropertyLoader | Load and save property files to a Service's PropertyBag |
| CPropertyMarshaller | A class for writing a property or propertybag into file |
| CSAX2XMLRPCHandler | |
| CStreamProcessor | An interface for setting and getting a stream object |
| CTiny2CPFHandler | |
| ►CTinyDemarshaller | A TinyXML demarshaller for extracting properties and property bags from a Component Property File (CPF) following the CORBA 3 standard |
| CD | |
| CTiXmlAttribute | An attribute is a name-value pair |
| CTiXmlAttributeSet | |
| ►CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CStringToBuffer | |
| CTiXmlComment | An XML comment |
| CTiXmlCursor | |
| CTiXmlDeclaration | In correct XML the declaration is the first entry in the file |
| CTiXmlDocument | Always the top level node |
| CTiXmlElement | The element is a container class |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlOutStream | |
| CTiXmlParsingData | |
| CTiXmlString | |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CXMLRPCDemarshaller | A DemarshallInterface for the XMLRPC Protocol |
| CXMLRPCMarshaller | Outputs a Property or PropertyBag into a text stream in the XML-RPC format |
| ►Nmqueue | |
| ►Cbinary_data_iarchive | This archive is capable of loading objects of serialization level 1 and 2 from a binary, non-portable format |
| ►Cuse_array_optimization | We provide an optimized load for all fundamental types typedef serialization::is_bitwise_serializable<mpl::_1> use_array_optimization; |
| Capply | |
| ►Cbinary_data_oarchive | This archive is capable of saving objects of serialization level 1 and 2 in a binary, non-portable format |
| ►Cuse_array_optimization | We provide an optimized load for all fundamental types typedef serialization::is_bitwise_serializable<mpl::_1> use_array_optimization; |
| Capply | |
| CDispatcher | This object waits on a set of open message queue file descriptors and signals the channel that has received new data |
| CMQChannelElement | Implements the a ChannelElement using message queues |
| CMQLibPlugin | The CORBA transport plugin |
| CMQSendRecv | Implements the sending/receiving of mqueue messages |
| CMQSerializationProtocol | |
| CMQTemplateProtocol | For each transportable type T, specify the conversion functions |
| CMQTemplateProtocolBase | For each transportable type T, specify the conversion functions |
| ►Nos | OS Abstractions such as Mutexes, Semaphores and Threads |
| CAtomicInt | C++ abstraction of atomic integer operations |
| Cbasic_iostreams | An IO stream based on strings |
| Cbasic_istreams | An basic_istream is a stream which can be read |
| Cbasic_ostreams | An basic_ostreams is a stream which can be written to |
| Cbasic_streams | This is a stream class for use in limited environments |
| CCleanupFunction | Use this to register a global cleanup function to the StartStopManager |
| CCondition | An object oriented wrapper around a condition variable |
| CInitFunction | Use this to register a global init function to the StartStopManager |
| ►Clocal_allocator | A simple local allocator which keeps a small pool which you can grow manually with grow() |
| Crebind | |
| ►Clocal_allocator< void > | |
| Crebind | |
| CMainThread | A class which represents the main() thread |
| CMutex | An object oriented wrapper around a non recursive mutex |
| CMutexInterface | An interface to a Mutex |
| CMutexLock | MutexLock is a scope based Monitor, protecting critical sections with a Mutex object through locking and unlocking it |
| CMutexRecursive | An object oriented wrapper around a recursive mutex |
| CMutexTimedLock | A MutexTimedLock locks a Mutex object on construction and if successful, unlocks it on destruction of the MutexTimedLock |
| CMutexTryLock | A MutexTryLock tries to lock an Mutex object on construction and if successful, unlocks it on destruction of the MutexTryLock |
| CPosixCookie | |
| Cprint_helper | |
| Cprintbufs | |
| Cprintstream | The printstream is a stream for printing characters to the terminal window |
| ►Crt_allocator | A real-time malloc allocator which allocates every block with oro_rt_malloc() and deallocates with oro_rt_free() |
| Crebind | |
| ►Crt_allocator< void > | |
| Crebind | |
| Crt_list | Implements a list with real-time insertion/removal of elements |
| CRTAI_Thread | |
| CSemaphore | An object oriented wrapper around a counting semaphore |
| CStartStopManager | This manager starts and stops all globally registered start/stop functions, without a particular order |
| Cstreambufs | A base class for all stream buffer operations |
| Cstring_helper | |
| Cstringbufs | A streambufs implementation based on strings |
| Cstringstreams | Stringstreams, are not guaranteed to be hard realtime |
| CThread | A Thread object executes user code in its own thread |
| CThreadInterface | A thread which is being run |
| CThreadWrapperData | |
| ►CTimer | This class allows to define a timer object which can be armed in single shot and periodic mode |
| CTimerInfo | |
| CTimeService | The TimeService is used for system-wide time keeping and conversions |
| CXenoCookie | |
| ►Nplugin | Classes and functions for creating and loading plugins |
| CPluginLoader | Loads plugins found on the filesystem and keeps track of found plugins, typekits and services |
| ►Nscripting | Parser code for the Orocos real-time scripting language |
| CArgumentsParser | This is a parser that you construct to parse a set of arguments |
| CCallFunction | An action which calls a FunctionFraph for execution in a ExecutionEngine |
| CCommandBinary | |
| CCommandComposite | Based on the software pattern 'composite', this class RTT_SCRIPTING_API allows composing command objects into one command object |
| CCommandCounter | This command increments a counter when executed |
| CCommandDataSource | A Command which evaluates a base::DataSourceBase and always returns true |
| CCommandDataSourceBool | A Command which evaluates a internal::DataSource<bool> and returns the result of get() |
| CCommandFunction | A functor with the base::ActionInterface, for the case where the functor is a bool(void) |
| CCommandIllegal | A Command indicating that an error was encountered somewhere, most likely during the construction of another command |
| CCommandNOP | The empty command |
| CCommandString | This command displays a string when executed |
| CCommonParser | This class contains some very common parser definitions |
| CConditionBinaryCompositeAND | Compose an 'AND' function of two Conditions |
| CConditionBinaryCompositeOR | |
| CConditionBool | |
| CConditionBoolDataSource | A Condition which holds a boolean DataSource |
| CConditionBoolProperty | ConditionBoolProperty is a Condition which reads out a Property<bool> |
| CConditionCache | A conditional that evaluates and caches another Condition |
| CConditionCompare | A general compare condition |
| CConditionCompositeNOT | |
| CConditionDSDuration | A conditional that evaluates true after a certain time (in seconds) has passed, given by a DataSource |
| CConditionDuration | A conditional that evaluates true after a certain time has passed |
| CConditionExpire | A conditional that evaluates true until a certain time has elapsed since construction or the last reset() |
| CConditionFalse | A conditional that evaluates false |
| CConditionFunction | A functor with the ConditionInterface, for the case where the functor is a bool(void) |
| CConditionInterface | This interface represents the concept of a condition which can be evaluated and return true or false |
| CConditionInvert | A conditional that evaluates to the inverse of another Condition |
| CConditionOnce | A conditional that evaluates the first time true and afterwards always false (or vice versa) |
| CConditionParser | This is a class containing a parse function for conditions |
| CConditionTrue | A conditional that evaluates true |
| CConstructorParser | Parses type constructor syntax |
| CDataCallParser | This parser parses a call of the form "a.b( arg1, arg2, ..., argN )" |
| CDataSourceCondition | A class that wraps a Condition in a internal::DataSource<bool> interface |
| CDataSourceTime | A internal::DataSource which returns the time elapsed since the last reset in Seconds |
| CEdgeCondition | This class represents a conditional branch in a program tree |
| Ceol_skip_functor | Due to a bug in MSVC 2005, the operator() ends up with a null reference of the skipeol member Tried several workarounds, could not find one, except turning off optimization for this function |
| CEvalCommand | Evaluates a internal::DataSource<bool> in a command |
| CEvalCommandResult | The result of a command which evaluates a boolean DataSource |
| CExpressionParser | How we parse: this parser works like a stack-based RPN calculator |
| Cfatal_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 |
| Cfatal_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 |
| CFunctionFactory | A Factory which delivers operations which execute a FunctionGraph in an engine |
| CFunctionGraph | This class represents a function |
| CFunctionGraphBuilder | This class builds a program consisting of data contained in a program graph tree, based on the Boost Graph Library |
| Cparse_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 |
| Cparse_exception_illegal_identifier | |
| Cparse_exception_no_such_component | |
| Cparse_exception_no_such_constructor | |
| Cparse_exception_no_such_method_on_component | |
| Cparse_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 |
| Cparse_exception_semantic_error | Parse_exception class that is used for various semantic errors for which it was not worth defining a proper exception class |
| Cparse_exception_syntactic_error | Parse_exception class that is used for various syntactic errors for which it was not worth defining a proper exception class |
| Cparse_exception_undefined_value | |
| Cparse_exception_wrong_number_of_arguments | |
| Cparse_exception_wrong_type_of_argument | |
| CParsedStateMachine | State machine created by the scripting engine which represents a parsed state machine |
| CParser | This class is the public interface to the Orocos Program Parser Framework |
| CPeerParser | Get the peer and object from an invocation path like a.b.c.d() |
| Cprogram_load_exception | This exception is thrown when a program or state machine could not be loaded into a ProgramProcessor or StateMachineProcessor |
| Cprogram_unload_exception | This exception is thrown when a program or state machine could not be unloaded into a ProgramProcessor or StateMachineProcessor |
| CProgramGraphParser | A Parser for Orocos Program Scripts |
| ►CProgramInterface | A Program represents a collection of instructions that can be stepwise executed |
| CStatus | Placeholder of the ProgramStatus |
| CProgramService | This class represents a program as an Service in the Orocos TaskContext system |
| CPropertyParser | Get the property and bag from an invocation path like bag.subbag.prop |
| CScriptingService | This interface allows to load program scripts and state machines and allows execution of code |
| CScriptParser | Parsers and executes any RTT script you throw at it |
| Csemantic_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 |
| CSendHandleAlias | Keeps track of a DataSource which has a SendHandle and the factory for creating the collect functions associated with that handle |
| CStateDescription | This class represents a state with all actions stored in an external program |
| CStateGraphParser | 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 |
| CStateInterface | A State contains an entry, run, handle and exit program |
| ►CStateMachine | A hierarchical StateMachine which is loaded in the Program Processor |
| CStatus | Enumerates all possible state machine statuses |
| CStateMachineBuilder | |
| CStateMachineService | This class represents a stateMachine as a Service in the Orocos TaskContext system |
| ►CStatementProcessor | This class parses and executes a single scripting statement |
| CD | |
| Csyntactic_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 |
| CTryCommand | A command which tries another command and stores the result in a internal::DataSource<bool> |
| CTryCommandResult | Returns the (accept/reject) status of another command |
| CValueChangeParser | This class is responsible for parsing constant definitions, variable definitions, variable change instructions, and alias definitions |
| CValueParser | A class for parsing const values |
| CVertexNode | This class represents elements in a program tree |
| Cwrong_context_params_exception | |
| ►Ntypes | Classes for typekits for describing and handling user data types |
| CBinaryOp | |
| CBinaryOperator | An operator which reads a two DataSources and returns a modified result |
| CBoolTypeInfo | Write boolean as 'true' or 'false' |
| CBoostArrayTypeInfo | Template for data types that are of type boost::array<U,int> |
| Ccarray | Wraps a C array such that we can return a C array from a DataSource |
| CCArrayTypeInfo | Template for data types that are C-style arrays |
| CCompositionFactory | A factory for composing/decomposing and converting types to a form suitable for persistent storage, such as an XML file |
| CEmptySendHandle | This is a placeholder for scripting purposes |
| CEmptyTypeInfo | Empty implementation of TypeInfo interface |
| CEnumTypeInfo | Type information for Enum types for which they are convertible to int |
| CGlobalsRepository | An RTT::ConfigurationInterface for holding global variables |
| CMemberFactory | |
| COperatorRepository | This class builds on upon construction all expression operators known to Orocos |
| CPrimitiveSequenceTypeInfo | New-style SequenceTypeInfo which offers type info for sequences which can NOT be sent over flow ports |
| CPrimitiveTypeInfo | This template class allows primitive types, which are not sent over ports, to be added to Orocos |
| CRealTimeTypekitPlugin | This interface defines the types of the realTime package |
| CRTStringTypeInfo | Standard string specialisation that removes decomposition |
| Csequence_constructor_datasource | Helper DataSource for constructing sequences with a variable number of parameters |
| Csequence_ctor | Sequence constructor which takes the number of elements in the sequence |
| Csequence_ctor2 | Constructs a sequence from the number of elements and a prototype element for these elements |
| Csequence_varargs_ctor | See NArityDataSource which requires a function object like this one |
| CSequenceBuilder | Constructs an sequence with n elements, which are given upon construction time |
| CSequenceTypeInfo | Old-style SequenceTypeInfo which offers type info for sequences which can be sent over flow ports |
| CSequenceTypeInfoBase | Template for data types that are C++ STL Sequences with operator[], size() and capacity() methods |
| CStdStringTypeInfo | Standard string specialisation that removes decomposition |
| CStdTypeInfo | Type information for standard C types or structs of which no introspection is required |
| CStdVectorBuilder | |
| CStdVectorTemplateTypeInfo | Template class for std::vector<T> typekits, providing a alternative demarshalling function for properties and optionally ostream printing |
| CStdVectorTypeInfo | This class tells Orocos how to handle std::vector<double> |
| CStreamFactory | |
| CStructTypeInfo | Type Information for data types that are structs, ie all user data types fall in this category |
| CTemplateCompositionFactory | |
| CTemplateConnFactory | |
| CTemplateConstructor | The constructor classes allow to define type constructors or type conversions (convert type B from type A) |
| CTemplateTypeInfo | This template class allows user types to be used in all Orocos primitives |
| CTemplateValueFactory | |
| CTransportPlugin | A class which registers TypeTransporter instances to types |
| Ctype_discovery | This archive is capable of decomposing objects of serialization level 1 and 2 into part data sources |
| CTypeConstructor | This interface describes how constructors work |
| CTypeInfo | A class for representing a user type, and which can build instances of that type |
| CTypeInfoGenerator | All generator classes inherit from this object in order to allow them to be added to the TypeInfoRepository |
| CTypeInfoName | This helper class allows only type names to be added to Orocos |
| CTypeInfoRepository | This class contains all known types to Orocos |
| CTypekitPlugin | This interface defines how additional typekits are loaded into Orocos |
| CTypekitRepository | This class allows the RTT to be extended with additional typekits (TypekitPlugin), such as for kinematics or any library foreign to Orocos |
| CTypeMarshaller | Objects implementing this interface have the capability to convert data sources to and from a binary representation |
| CTypeStreamSelector | |
| CTypeStreamSelector< T, false > | |
| CTypeStreamSelector< T, true > | |
| CTypeTransporter | This interface defines the function a transport protocol must support in order to allow Orocos components to remotely communicate one data type |
| CUnaryOp | UnaryOperator contains information on some unary operator that operates on one arg of a certain type |
| CUnaryOperator | An operator which reads a single internal::DataSource and returns a modified result |
| CValueFactory | Creates all value objects of a certain type |
| CActivity | An Activity is an object that represents a thread |
| CAlias | 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 |
| CArgumentDescription | Description of one Argument of a Command |
| CAttribute | An Attribute has a name and contains data which can be set and get |
| CCleanupHandle | A connection Handle of a (connected) slot which disconnects and cleans up (free all resources) the connection object in its destructor |
| CComponentFactories | A global variable storing all component factories added with ORO_LIST_COMPONENT_TYPE |
| CComponentFactoryLoader | A helper class storing a single component factory in case of static library deployments |
| CComponentLoader | |
| CConfigurationInterface | A class for keeping track of Attribute, Constant and Property objects of a TaskContext |
| CConnPolicy | A connection policy object describes how a given connection should behave |
| CConstant | As opposed to a Attribute, a Constant can not be assigned to a new value after creation |
| CDataFlowInterface | The Interface of a TaskContext which exposes its data-flow ports |
| CExecutionEngine | An execution engine serialises (executes one after the other) the execution of all commands, programs, state machines and incomming events for a task |
| Cfile_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 |
| Cfinder | |
| Cget_capacity | |
| Cget_size | |
| CHandle | The Handle holds the information, and allows manipulation, of a connection between a internal::Signal Handler function and the Signal itself |
| CInputPort | A component's data input port |
| Cinvalid_handle_exception | Exception thrown when a factory is requested to create an object with an invalid SendHandle |
| ►CLogger | A simple logging class to debug/ analyse what is going on in the Orocos system |
| CD | This hidden struct stores all data structures required for logging |
| CIn | Notify the Logger in which 'module' the message occured |
| CMarshalling | Service requester to load and save properties of a TaskContext |
| Cname_not_found_exception | Exception thrown when a factory is requested to create an object with an unknown name |
| Cno_asynchronous_operation_exception | Exception thrown when a factory is requested to produce an asynchronous object while it is not available for that operation |
| Cnon_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 |
| COperation | The operation ties a C or C++ function into a component interface |
| COperationCaller | A OperationCaller serves as a placeholder (aka 'proxy') for a remote Operation |
| COperationInterface | Holds all exported operations of a component and is able to produce callers for these operations |
| COperationInterfacePart | This class defines the interface for creating operation objects without using C++ templates |
| COutputPort | A component's data output port |
| Cparse_exception | This is the uppermost exception class in the parser system |
| CProperty | A property represents a named value of any type with a description |
| ►CPropertyBag | A container for holding references to properties |
| CFindPropType | A function object for finding a Property by name and type |
| CRemoveMsg | |
| CScopedHandle | A scoped connection Handle of a (connected) slot which disconnects a slot from a signal in its destructor |
| CScripting | The method interface of the scripting plugin |
| CSendHandle | The SendHandle is used to collect the result values of an asynchronous invocation |
| CService | This class allows storage and retrieval of operations, ports, attributes and properties provided by a component |
| CServiceRequester | An object that expresses you wish to use a service |
| CTaskContext | The TaskContext is the C++ representation of an Orocos component |
| Cwrong_number_of_args_exception | Exception thrown when a factory is requested to create an object but the wrong number of arguments was given |
| Cwrong_types_of_args_exception | Exception thrown when a factory is requested to create an object, but a wrong argument type was given |
| ▼Nstd | STL namespace |
| Cequal_to< const _Tp & > | |
| Cgreater< const _Tp & > | One of the comparison functors |
| Cless< const _Tp & > | One of the comparison functors |
| Cnot_equal_to< const _Tp & > | One of the comparison functors |
| Cternary_function | |
| CCorbaOperationCallerCall | Calls a CORBA method |
| CCorbaOperationCallerCollect | Collects a CORBA method |
| Ccyg_recursive_mutex_t | |
| Cfd_watch | |
| Coro__xchg_dummy | |
| Coro_atomic_t | Structure that contains an int for atomic operations |
| Coro_rtai_cond_t | |
| Coro_rtai_sem_t | |
| Coro_timespec | |
| CPOAUtility | |
| Crt_cond_t | |
| CRT_INTR | |
| Crt_mutex_impl_t | |
| CRTOS_TASK | |
| CRTT_corba_CConfigurationInterface_i | |
| CRTT_corba_COperationInterface_i | |
| CRTT_corba_CSendHandle_i | |
| CRTT_corba_CService_i | |
| CRTT_corba_CServiceRequester_i | |
| CRTT_corba_CTaskContext_i | |
