|
MIRA
|
| ▶Nboost | |
| ▶Ncv | |
| CDataType< mira::ImgPixel< T, Channels > > | |
| ▶Nmira | Specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec> |
| ▶NColor | |
| CHSV | Color in HSV color space |
| CLab | Color in CIE Lab color space The CIE Lab color space is derived from the XYZ color space and is designed to approximate human vision |
| CRGB | The different color spaces |
| CRGBA | Color in RGBA color space |
| CXYZ | Color in CIE 1931 XYZ color space The CIE XYZ color space is the master for the derived CIE Lab color space, which is perceptually uniform and hence will be used more often for visualization purposes |
| ▶Ndetail | |
| CAutoCountingEnum | |
| CAutoCountingHelper | |
| CAutoCountingHelper< T, CountType, true > | |
| CCVDataTypeVecEnsureDepth | |
| CCVDataTypeVecEnsureDepth< T, Channels, false > | |
| CCVDataTypeVecEnsureDepthAndType | |
| CCVDataTypeVecEnsureDepthAndType< T, Channels, false > | |
| CExtensibleEnumBase | |
| CExtensibleEnumBase< T, true, CountType, UseMutex > | |
| CExtEnum_RemoveBrackets | |
| CExtEnum_RemoveBrackets< void(T)> | |
| CHasAssignHelper | |
| CNoValueEnum | |
| CPowerComputer | |
| CPowerComputer< T, 0 > | |
| CPowerComputer< T, 1 > | |
| ▶NHumanReadableSerialization | The serialization of time-related types Time, Date and Duration is primarily aimed at efficiency and precision |
| CDate | Derivation of mira::Date with human-readable serialization |
| CDuration | Derivation of mira::Duration with human-readable serialization |
| CTime | Derivation of mira::Time with human-readable serialization |
| ▶Njson | |
| CJSONDefaultPrecision | JSONDefaultPrecision is a singleton that provides a mechanism to control the default precision for output of floating-point JSON values |
| CQueryNumberResult | A struct used for return value of getNumberElementIfExists() |
| CQueryValueResult | A struct used for return value of getElementIfExists() |
| ▶NPrivate | |
| CActiveEdgeCuts | |
| CArgumentTuple | |
| CConcreteRPCInvoker | |
| CEdgeCuts | |
| CFunctionTraits | |
| CFunctionTraits< F & > | |
| CFunctionTraits< F && > | |
| CFunctionTraits< F, typename std::enable_if< Private::HasParenthesis< F >::value >::type > | |
| CFunctionTraits< R(*)(Args...)> | |
| CFunctionTraits< R(Args...)> | |
| CFunctionTraits< R(C::*)(Args...) const > | |
| CFunctionTraits< R(C::*)(Args...)> | |
| CFunctionTraits< R(C::*)> | |
| CHasParenthesis | |
| CInterval | |
| CIntervals | |
| CMemberInvoker | |
| CRPCInvokeHelper | |
| CRPCInvokeHelper< void > | |
| ▶Nserialization | |
| CAcceptDesiredVersion | Tag class used as parameter to ReflectorInterface::version() etc |
| CIgnoreMissing | Marker for indicating parameters that should be ignored if they are missing in the config file |
| CReadMapPairHelper | |
| CReflectCollectionCount | Can be specialized for a concrete derived RecursiveMemberReflector to reflect the size of collections like vectors, arrays, lists, maps, etc |
| CReflectCollectionCount< JSONDeserializer, Collection > | Specialization for JSONDeserializer which counts the item nodes in the parent node to recover the item count, which is much more user friendly, since the user does not need to provide the count himself |
| CReflectCollectionCount< JSONDeserializer, std::map< std::string, mapped_type > > | |
| CReflectCollectionCount< JSONSerializer, Collection > | Specialization for JSONSerializer which does not write the item count explicitly |
| CReflectCollectionItems | Can be specialized for a concrete derived RecursiveMemberReflector to reflect the items of collections like vectors, arrays, lists, maps, etc |
| CReflectedAsPointer | For internal use only: Holds value=true, if the type T is ever reflected as pointer with Reflector within this translation unit (C file), otherwise false |
| CReflectReadMap | Reflects generic associative containers like map, multimap, hash_map |
| CReflectReadMapItems | |
| CReflectReadMapItems< JSONSerializer, std::map< std::string, mapped_type > > | |
| CReflectReadSeq | Reflects generic sequential containers like vectors, list, deque (Read Only / Serialization) |
| CReflectReadSet | Reflects generic set containers like set, multiset |
| CReflectReadSetItems | |
| CReflectWriteMap | Reflects generic associative containers like map, multimap, hash_map |
| CReflectWriteMapItems | |
| CReflectWriteMapItems< JSONDeserializer, std::map< std::string, mapped_type > > | |
| CReflectWriteSeq | Reflects generic sequencial containers like vectors, list, deque (Write Only / Deserialization) |
| CReflectWriteSet | Deserializes generic set containers like set, multiset |
| CReflectWriteSetItems | |
| CSetReflectedAsPointer | |
| CWriteMapPairHelper | |
| ▶Nsingleton | |
| CCreateStatic | Implementation of the CreationPolicy that is used by the Singleton template |
| ▶CCreateUsing | Implementation of the CreationPolicy that is used by the Singleton template |
| CAllocator | |
| CCreateUsingNew | Implementation of the CreationPolicy that is used by the Singleton template |
| CEagerInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| CExplicitInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| CLazyInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| ▶CMutexLock | Implementation of the LockPolicy that is used by the Singleton template |
| CVolatile | |
| CNoDestroyLifetime | Implementation of the LifetimePolicy that is used by the Singleton template |
| ▶CNoLock | Implementation of the LockPolicy that is used by the Singleton template |
| CLock | |
| CVolatile | |
| CNormalLifetime | Implementation of the LifetimePolicy that is used by the Singleton template |
| CAbstractAuthority | This is the abstract base class of local and remote authority classes |
| CAbstractChannel | |
| CAbstractChannelSubscriber | |
| CAbstractDeferredInvoker | Abstract interface for DeferredInvoker which is a class to support different RPC backends |
| CAbstractInterfaceCallbackHandler | Abstract interface for derived handler(s) |
| CAbstractReflector | Abstract base class for most Reflectors |
| CAbstractRemotePropertyNode | Special derived class of PropertyNode, that allows to handle "remote properties" transparently |
| CAbstractRPCClient | Abstract interface for RPCClient |
| CAbstractRPCHandler | Abstract interface for derived RPCHandler(s) |
| CAbstractTransformerNode | Abstract base class where all other different types of transformation nodes must be derived from |
| CAccessor | The Accessor class is used as an adapter to reduce the code bloat within the reflection and serialization implementations |
| CAccessorGetterPart | Implements the "getter part" of an Accessor |
| CAccessorGetterPart< Getter< T > > | |
| CAccessorGetterPartInternalRedirect | This class is used as additional reflection redirect |
| CAccessorSetterPart | Implements the "setter part" of an Accessor |
| CAccessorSetterPart< NullSetter< T > > | |
| CAccessorSetterPart< Setter< T > > | |
| CAESConfiguration | The AES configuration for encryption and decryption |
| CAngle | Unsigned angle that is represented using radians |
| CAngleBase | Base class template for derived Angle implementations |
| CArrowObject | |
| ▶CAuthority | Authorities act as a facade to the framework |
| CRWAccessFlags | Channel access flags |
| CAuthorityDescription | This is the descriptive part of an authority |
| CAuthorityManager | Central instance that stores all created Authorities |
| CAuthorityRuntime | This class contains threading functionality that can be shared among different authorities so that all of them use the same thread (dispatcher thread) |
| CAxesCovObject | Visualization of covariances for AxesObject |
| CAxesObject | |
| CAxesVisualization | |
| CBinaryBufferStreamBase | Although this class is not a template we must keep its methods inline for performance reasons! write() and read() are called very often! |
| CBinaryDeserializer | Deserializer that uses BinaryIstream to deserialize the objects from binary format |
| CBinaryIosBase | Helper class that is a base for binaryostream and binaryistream in the same way as ios_base is a base of ostream and istream |
| CBinaryIstream | Input stream adapter that can be assigned to any input stream and allows binary input using the >> stream operators |
| CBinaryOstream | Output stream adapter that can be assigned to any output stream and allows binary output using the << stream operators |
| ▶CBinaryRPCBackendTempl | Provides binary client and server side requests and responses |
| CClientRequest | Binary client-side request |
| CClientResponse | Binary client-side response |
| CServerRequest | Binary server-side request |
| CServerResponse | Binary server-side response |
| CBinarySerializer | |
| ▶CBinarySerializerCodec | Abstract base class for codecs that can be used with BinarySerializer and BinaryDeserializer |
| CFourcc | A four-character code that is used to identify data formats and codecs |
| CBinarySerializerMixin | Used by BinarySerializer and BinaryDeserializer |
| CBinarySerializerTag | Serializer that uses BinaryOstream to serialize the objects in binary format |
| CBresenhamLineIterator | Implements an iterator that is able to iterate over a Bresenham line point by point using the prefix ++operator and –operator |
| CBuffer | Generic buffer class that can be used as a replacement for std::vector whenever copying and reallocation of internal array buffer needs to be avoided |
| CBufferStream | A stream class for input and output of data to/from a wrapped Buffer |
| ▶CCallStack | Encapsulates unix call stack functionality |
| CSymbol | Contains all information of a single function symbol in the call stack |
| CCameraOrbitTool2D | |
| CCameraOrbitTool3D | |
| CChannel | An exception that occurs whenever a channel has no data |
| CChannelBuffer | Typed ChannelBuffer |
| CChannelBuffer< T * > | Specialization for polymorphic types (only classes derived from mira::Object are supported!) |
| ▶CChannelBuffer< void > | Specialization for void (Untyped ChannelBuffer), which only holds the StampedHeader |
| CSlot | Typed slot derived from ChannelBufferBase::Slot |
| ▶CChannelBufferBase | Base class that manages the slots of channels by providing read and write access to them |
| CListItem | Implements double-linked list item |
| CSlot | Container for storing a single data element in the linked list |
| CChannelBufferPromoter | Forward decl |
| CChannelBufferPromoter< U * > | Specialization of ChannelBufferPromoter for polymorphic pointer channel buffers |
| CChannelBufferPromoterCommon | Forward decl |
| CChannelContentChange | Class that can be registered as a filter when subscribing to channels to only get a callback when the content of the channel changes |
| CChannelHysteresis | Class that can be registered as a filter when subscribing to channels to only get a callback when the state of the hysteresis trigger changes |
| CChannelInterval | Class that can be registered as a filter when subscribing to channels to only get a callback in a specified interval |
| ▶CChannelManager | An exception that occurred whenever a channel does not exist |
| CChannelInfo | Informations about a channel that also provides ordering of channels by id |
| CChannelProperty | The concrete typed ChannelProperty template class |
| CChannelPropertyBase | Base class for ChannelProperty template class |
| CChannelPropertyDelegateLineEdit | Special LineEdit for ChannelProperty delegate for Property Editor |
| CChannelPropertyProxy | Proxy class that is returned/set by the getter and setter methods of ChannelProperty |
| CChannelRead | An object that allows read access to data of a channel |
| ▶CChannelReadInterval | An object that allows read access to a whole interval of channel data |
| Cconst_iterator | Const iterator for iterating over the interval |
| CChannelReadWriteBase | |
| CChannelReadWriteBase< Derived, void > | Specialization for untyped channels which just return the StampedHeader as data |
| CChannelReadWriteCommonBase | |
| CChannelReadWriteShared | Internally used by ChannelReadWriteBase! It contains the information about the channel and slot that can be shared between different ChannelRead/Write objects |
| CChannelReadWriteTraits | |
| CChannelReadWriteTraits< ChannelRead< T > > | |
| CChannelReadWriteTraits< ChannelRead< void > > | |
| CChannelReadWriteTraits< ChannelWrite< T > > | |
| CChannelReadWriteTraits< ChannelWrite< void > > | |
| CChannelSubscriber | Implements AbstractChannelSubscriber for a concrete data type |
| CChannelSynchronizer | |
| CChannelSynchronizerBase | |
| CChannelVectorSynchronizer1 | Class that can be registered as a filter when subscribing to more than one channel to only get a callback when all channels have data with a similar timestamp (differ only in the specified tolerance) |
| CChannelWrite | An object that allows exclusive write access to data of a channel |
| CCircle | Represents a circle with a center and a radius |
| CClass | Class object which supports some kind of class reflection |
| CClassFactory | What should i say, the class factory |
| CClassProxy | The class proxy assures that the pointer to the class object is always valid |
| CCodecDialog | A dialog for adding, removing and editing codecs |
| CCodecWidget | Widget for displaying used codecs and changing them via a dialog |
| CCollapsibleTreeHeader | Header for tree widgets with additional collapse/expand button in the first column |
| CColorBase | Base interface for all colors in different color spaces The class provides a base interface for all color (space) classes |
| ▶CColormap | Base class for color colormaps |
| Citerator | Iterator that can iterate over the whole color colormap similar to STL iterators on containers |
| CColormapProperty | A special property class that can be used as member, if you want to provide a ComboBox where the user is able to select the available and registered color colormaps |
| CColormapPropertyComboBox | |
| CComplementary10Colormap | A discrete colormap with 10 complementary colors |
| CComplementary6Colormap | A discrete colormap with 6 complementary colors |
| ▶CCompoundMeta | Meta information for complex compounds, like classes and structs |
| CMember | A single member of the compound |
| CConcreteBinaryDeserializer | |
| CConcreteBinarySerializer | |
| CConcreteChannel | |
| CConcreteRemoteConnection | |
| CConcreteRemoteOutgoingConnection | |
| CConfigurationLoader | Class for loading, parsing, modifying and interpreting application configuration files |
| CConfigurationLoaderPlugin | Base class for loader plugins |
| CConfigurationPreparePlugin | Base class for prepare plugins |
| CContinuousColormap | Base class for continuous color colormaps |
| CCovObject | Visualization of covariances |
| CCRSplineInterpolator | 1D cubic Hermite spline interpolator |
| CCyclicRunnable | This class extends threads by the ability to execute an operation repeatedly in an defined interval |
| CDefaultInitializer | Reflector that visits the reflect method of objects in order to initialize them using the specified default values |
| CDefaultTextVisualizationBase | |
| CDeferredInvokerFinishHandler | Handler that is called when a deferred RPC call was executed and finished and therefore when the response is available |
| CDeg2RadNonNegativeType | A tag type used as parameter type in deg2radSetter, signalling that negative values are not permitted |
| CDegree | Unsigned angle that is represented using degrees |
| CDegreeBase | Base class for angle classes that represent angles using degrees |
| CDeserializer | Is a special reflector that is used for deserialization |
| CDeserializerFormatMixin | Used by BinaryDeserializer, see SerializerFormatMixin above |
| CDeserializerFormatMixin01Base | |
| CDeserializerFormatMixin< BinaryStream, 0 > | |
| CDeserializerFormatMixin< BinaryStream, 1 > | |
| CDeserializerFormatMixin< BinaryStream, 2 > | |
| CDiagnosticRunnable | |
| CDiagnosticsModule | Base class for modules that want to use diagnostics and set the current status |
| ▶CDiscoverService | Service that is used to discover other running frameworks in the same network using multicast on |
| CAnnounceMessage | |
| CDiscreteColormap | Base class for discrete color colormaps |
| ▶CDispatcherThread | Class that can be used whenever you want to have ONE thread where several handlers are assigned to |
| CQueueItem | XXX |
| CTimer | Class representing timers and tasks that can be registered and executed by the dispatcher thread |
| CXUnrecoverableFailure | Exception that can be thrown in every handler to indicate an unrecoverable failure |
| ▶CDistanceLUT | This class creates a look up table (LUT) to calculate the minimum and maximum Euclidean distance between a point and cells that are arranged in a regular grid |
| CCellDist | A struct to store the minimal and maximal distance of the cell towards the center point |
| CRegion | Provides a view on a portion of the Distance LUT and can be obtained by calling DistanceLUT::getRegion() |
| CDuration | Use this class to represent time durations |
| CDurationDialog | A dialog for selecting a duration |
| ▶CDynamicPoints | |
| CPointData | |
| CDynamicRenderable | Abstract base class for renderables based on dynamically growing vertex and index buffers |
| CEagerSingleton | Provided for convenience |
| CEagerSingletonNoLock | Provided for convenience |
| CEditorPart | An editor is typically used to edit or browse data or objects |
| CEditorPartArea | This is a replacement for QMdiArea |
| CEditorPartAreaTabBar | |
| CEditorPartTitleBar | |
| CEditorPartWindow | |
| CEigenFormat | Base class for formatting eigen matrices |
| ▶CErrorService | Class that allows to store errors persistently in a SQLite database |
| CError | Error informations |
| ▶CException | Base class for exceptions |
| CInfo | The info packet that is added in MIRA_THROW and MIRA_RETHROW |
| CExceptionCallStackSize | ExceptionCallStackSize is a singleton that provides a mechanism to control the depth of the callstack that is stored with exceptions (e.g |
| CExplicitSingleton | Provided for convenience |
| CExtensibleEnum | ExtensibleEnum is a base for derived classes that can be extensible 'replacements' for enum types |
| CExtensibleEnum< T, true, Counting, CountType, UseMutex > | |
| CFlowLayout | Layout, where the items are first laid out horizontally and then vertically when each line in the layout runs out of space |
| CFormulaeColormap | A class for creating formula based color maps |
| CFormulaeColormapBase | Internal base class for formulae based color maps |
| CFramework | This class represents the core element of a modular application |
| ▶CFrameworkGraph | Represents the whole computation graph with all known units/authorities and channels within their namespaces |
| CAuthorityNode | Represents a single authority in the framwork computation graph |
| CChannelNode | Represents a single channel in the framwork computation graph |
| CFrameworkNode | Represents a framework in the framework computation graph |
| CNamespaceNode | Represents a namespace in the framework computation graph within the overall namespace hierarchy |
| CNode | Base class for all nodes in the framework computation graph |
| CFrameworkGraphMixin | |
| CFrameworkGraphMixin< C, void > | |
| CFrameworkMessageHeader | Data that is sent as header in each message between remote frameworks |
| CFrameworkTransformer | |
| CFrameworkTransformerNode | |
| CFrameworkTransformReadAccessor | |
| CFrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolator > | |
| CFrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorExtrapolationLimit > | |
| CFrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorNearestNeighbourExtrapolator > | |
| CFrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorNoExtrapolation > | |
| CFrameworkTransformReadAccessor< ChannelTransformType, NearestNeighborInterpolator > | |
| CFrameworkTransformWriteAccessor | |
| ▶CFrameworkWithGui | |
| CApplication | Implements our own Application derived from QApplication in order to overwrite the notify method |
| CFromHex | Can be used with fromString to convert hex strings into numbers |
| CFromOct | Can be used with fromString to convert oct strings into numbers |
| CFunctionRunnable | Runnable that wraps any function pointer |
| ▶CGeneralBresenhamLineIterator | This more general iterator basically follows the design of BresenhamLineIterator, but works on an arbitrary-dimensional line and handles real-valued start and end positions |
| CAxis | Add the type-dependent start and end value to the axis data struct |
| CGeneralBresenhamLineIteratorBase | Guaranteeing longest axis as drive axis allows some simplification/optimization in step |
| CGeneralBresenhamLineIteratorBase< Drive, false > | Specialization for DrivenByLongestAxis=false (driving axis given explicitly: No need to determine the drive axis, but stepping is a little more complex |
| ▶CGeneralBresenhamLineIteratorCommonBase | |
| CAxisBase | Data structure containing the numtype-independent relevant variables for one axis (dimension) of the line |
| CGenericTransformer | A generic transformer base class that can be used with different types of actual transformation nodes |
| CGetter | Holds a boost::function object to a special getter function that must meet the signature "T method()" |
| CGradientColormap | A class for creating continuous color maps based on linear gradients between predefined points |
| CGradientColormapBase | Internal base class for linear gradient color maps |
| CGrayscaleColormap | A continuous grayscale colormap |
| CGridObject | |
| Cgzstreambase | |
| Cgzstreambuf | |
| Chas_assign | Evaluates to std::true_type, if U can be assigned to T, i.e |
| CHashDigest | A generic hash digest, which consists of an array of bytes |
| CHashStream | A template base class for hash functions based on std::ostream |
| CHashStreamBuf | A generic hash streambuf class |
| CHasPublicDefaultConstructor | Type trait that indicates whether or not a type can be constructed using the public default constructor |
| CHSVColormap | A continuous HSV colormap |
| CIAdaptable | An interface for an adaptable object |
| CIAuthorityProvider | Abstract interface for classes that can provide an authority via the getAuthority() method |
| CIFrameworkTransformer | IFrameworkTransformer defines RPC methods provided by FrameworkTransformer |
| CIFrameworkTransformerLinkType | Extension of IFrameworkTransformer supporting link types |
| Cigzstream | Use igzstream and ogzstream analogously to ifstream and ofstream respectively |
| CImageObject | |
| CImg | Class for typed images |
| CImg< T, 1 > | Specialized typed image with 1 channel This template class provides convenient way to create an image with known type and only 1 channel by using Img<Type> |
| CImg< void, 1 > | Untyped image class This class provides a fully dynamic image, where type and channels are not known at compile time |
| ▶CImgBase | ImgBase class |
| CImgFormat | Image storage format description (used e.g |
| CImgConstIterator | Const image iterator that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| CImgIterator | Image iterator that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| CImgIteratorBase | |
| CImgPixel | Dynamic ImgPixel class template ImgPixel class providing flexible types and channels |
| CImgPixel< T, 1 > | Specialization of PixelBase class for 1 channel |
| CImgPixel< T, 2 > | Specialization of PixelBase class for 2 channels |
| CImgPixel< T, 3 > | Specialization of PixelBase class for 3 channels |
| CImgPixel< T, 4 > | Specialization of PixelBase class for 4 channels |
| CImgPixelBase | Base interface for ImgPixel classes This class wraps typed cv::Vect to represent an ImagePixel The Vect is typed by template parameter T and channels are set by template parameter Channels |
| CImgTypedBase | Base class for typed images |
| ▶CImgWidget | A widget that visualizes an Img |
| CIMouseListener | The mouse listener interface that can be implemented to react on user interaction |
| CIncrementalMoments | Incremental computation of one- and higher-dimensional statistical moments of first and higher orders (mean and variance, etc.) |
| ▶CIncrementalMoments< T, 1, 1 > | |
| CCtx | |
| CIncrementalMoments< T, 1, 2 > | |
| ▶CIncrementalMoments< T, D, 1 > | |
| CCtx | |
| CIncrementalMoments< T, D, 2 > | |
| CIndexSelectorProperty | A special property class that can be used to provide a mechanism for selecting an element by index from data representing a set of similar objects |
| CIndexSelectorProperty< false > | Explicit specialization for Transparent=false (different reflect() method) |
| CIndexSelectorPropertyBase | Base for template class IndexSelectorProperty |
| CInteractionListener3D | Listener for mouse events on movable objects in a 3D view |
| CIntervalFilter | Concept and base class for all Interpolators and Filters |
| CIntSignal | Structure used in signal handlers to pass the signal and callstack |
| CIOService | Wrapper class for boost::asio::io_service |
| CIPartListener | |
| CIRunnable | Base for all runnable classes that can be signaled when they need to run again |
| CIsAtomicSerializable | Type trait that indicates whether a type can be serialized as an atomic value |
| CIsAtomicSerializable< JSONValue > | |
| CIsAtomicSerializable< std::basic_string< CharT, Traits, Alloc > > | |
| CIsAtomicSerializable< UUID > | |
| CIsBitwiseSerializable | Type trait that indicates whether a type can be serialized bitwise by just copying the data buffer |
| CIsCollection | Type trait that indicates whether a type is a collection |
| CIsCollection< boost::geometry::model::ring< PointType > > | |
| CIsCollection< Buffer< T, Allocator > > | |
| CIsCollection< MetaTypeDatabase > | |
| CIsCopyAssignable | Type trait that evaluates to true if a type is copy assignable, false otherwise |
| CIsCopyAssignable< RemoteModule::ConnectionMap > | |
| CIsDefaultConstructible | IsDefaultConstructible<T>::value evaluates to true, if T is default constructible, otherwise false |
| CIsNotMetaSerializable | Type trait that indicates whether a type does not support to gather meta information about it, e.g |
| CIsNotMetaSerializable< Img< TPixel, TChannels > > | Mark image classes as not meta-serializable |
| CIsObjectTrackable | Type trait that indicates whether pointer tracking can be enabled for this type |
| CIsObjectTrackable< Buffer< T, Allocator > > | |
| CIsObjectTrackable< ChannelPropertyProxy > | |
| CIsObjectTrackable< TransformProperty > | |
| CIsPointerOrSharedPointer | Type trait that indicates whether a type is a pointer type or a shared pointer |
| CIsPointerOrSharedPointer< boost::shared_ptr< T > > | |
| CIsPointerOrSharedPointer< std::shared_ptr< T > > | |
| CIsTransparentSerializable | Type trait that indicates whether a type should be serialized "transparently", i.e |
| CIsTransparentSerializable< Accessor< Getter, Setter >, SerializerTag > | |
| CIsTransparentSerializable< AccessorGetterPartInternalRedirect< T >, SerializerTag > | |
| CIsTransparentSerializable< Angle< T >, SerializerTag > | |
| CIsTransparentSerializable< ColormapProperty, SerializerTag > | |
| CIsTransparentSerializable< Date, SerializerTag > | |
| CIsTransparentSerializable< DateSerializedAsIsoString, SerializerTag > | |
| CIsTransparentSerializable< Degree< T >, SerializerTag > | |
| CIsTransparentSerializable< Duration, SerializerTag > | |
| CIsTransparentSerializable< DurationSerializedAsIsoString, SerializerTag > | |
| CIsTransparentSerializable< Getter< T >, SerializerTag > | |
| CIsTransparentSerializable< IndexSelectorProperty< true >, SerializerTag > | |
| CIsTransparentSerializable< KnownFramework, SerializerTag > | |
| CIsTransparentSerializable< Path, SerializerTag > | |
| CIsTransparentSerializable< Radian< T >, SerializerTag > | |
| CIsTransparentSerializable< RemoteConnectionProxy, SerializerTag > | |
| CIsTransparentSerializable< ResourceName, SerializerTag > | |
| CIsTransparentSerializable< RSAKey, SerializerTag > | |
| CIsTransparentSerializable< RSASignature, SerializerTag > | |
| CIsTransparentSerializable< Setter< T >, SerializerTag > | |
| CIsTransparentSerializable< SignedAngle< T >, SerializerTag > | |
| CIsTransparentSerializable< SignedDegree< T >, SerializerTag > | |
| CIsTransparentSerializable< SignedRadian< T >, SerializerTag > | |
| CIsTransparentSerializable< Time, SerializerTag > | |
| CIsTransparentSerializable< TimeSerializedAsIsoString, SerializerTag > | |
| CIsTransparentSerializable< TransformProperty, SerializerTag > | |
| CIsTransparentSerializable< XMLDom, SerializerTag > | |
| CIsTransparentSerializable< XMLDom, XMLSerializerTag > | |
| CIsTransparentSerializableHelper | |
| CIteratablePriorityQueue | |
| CIteratorRangeContainer | Wraps an STL conform container around a range of values within another container |
| ▶CIVisualization2DSite | |
| CCamera | |
| ▶CIVisualization3DSite | The interface of a Visualization3DSite |
| CCamera | |
| CIVisualizationSite | The primary interface between a Visualization and the container of the visualization (e.g |
| CIVisualizationSiteTransformable | The interface between a Visualization and the container of the visualization (e.g |
| CIVisualizationTextItem | |
| CIVisualizationTextSite | |
| CIVisualizationTextTraceItem | |
| CIVisualizationTextTraceSite | |
| CIWorkbenchPart | |
| CIWorkbenchPartSite | The primary interface between a workbench part and the workbench |
| CJetColormap | A continuous Jet colormap |
| CJSONDeserializer | Deserializer for serializing objects from JSON format |
| ▶CJSONRPCBackend | Provides JSON client and server side requests and responses |
| CClientRequest | JSON client-side request |
| CClientResponse | JSON client-side response |
| CServerRequest | JSON server-side request |
| CServerResponse | JSON server-side response |
| CJSONRPCResponse | Wraps a JSON RPC call response |
| CJSONSerializer | Serializer for serializing objects in JSON format |
| CKnownFramework | Information and settings for a known remote framework |
| CLazySingleton | Provided for convenience |
| CLazySingletonNoLock | Provided for convenience |
| CLibraryInfo | |
| CLibraryRegistry | A registry for shared libraries |
| CLibraryVersion | |
| CLine | Represents a line segment that is spanned by two given points |
| CLinearInterpolator | 1D linear interpolator |
| CLinearInterpolatorExtrapolationLimit | 1D linear interpolator |
| CLinearInterpolatorNearestNeighbourExtrapolator | 1D linear interpolator |
| CLinearInterpolatorNoExtrapolation | 1D linear interpolator |
| CLineEditClear | Provides a QLineEdit widget that has a small button on its right side for clearing the content |
| CLineListObject | Renders a line strip as billboard chain |
| CLineStripObject | Renders one or more line strips |
| CLockedPropertyNodeAccess | |
| CLockedPropertyNodeAccess< NodeType, ValueType, false, true > | |
| CLockedPropertyNodeAccess< NodeType, ValueType, true, false > | |
| CLockedPropertyNodeAccess< NodeType, ValueType, true, true > | |
| CLockedPropertyNodeAccessCommon | |
| CLogConsoleSink | Special class that uses LogTxtStreamSink as a base and cout as stream Provided for logging to console |
| CLogCore | Single instance of the core logging class |
| ▶CLogCustomizableFilter | A customizable log filter to match the users needs |
| CAndOperator | Operator class used to combine two custom filters by the & operator |
| CClass | Class filter, used to filter log entries with a given class name |
| CCustomFilter | Helper class to get the type info of the derived class |
| CCustomFilterBase | Abstract base class for custom filters |
| CNamespace | Namespace filter, used to filter log entries with a given namespace |
| COrOperator | Operator class used to combine two custom filters by the | operator |
| CSeverity | Severity filter, used to filter log entries with a given severity level |
| CThread | ThreadID filter, used to filter log entries with a given thread id |
| ▶CLogCustomizableFormatter | A customizable formatter |
| CClass | Class format, used to write the class name of the log entry to the log format |
| CCustomFormatBase | Abstract base class for all CustomFormats |
| CFile | File format, used to write the file of the log entry to the log format |
| CFunction | Function format, used to write the function name of the log entry to the log format |
| CGeneric | Generic format, used to write various data to the log format |
| CLine | Line format, used to write the line of the log entry to the log format |
| CMessage | Message format, used to write the message of the log entry to the log format |
| CNameSpace | Namespace format, used to write the name space of the log entry to the log format |
| CSeverity | Severity format, used to write the severity level of the log entry to the log format |
| CThread | ThreadID format, used to write the thread id of the log entry to the log format |
| CTime | Time format, used to write the time of the log entry to the log format |
| CUptime | Uptime format, used to write the up-time of the logging core to the log format |
| CLogFileSink | A logging sink for file, which supports log file rotation and daily log files |
| CLogFilterBase | Abstract base class for log filters |
| CLogFormatterBase | Abstract base class for sink formatters |
| CLogger | Helper class that is created to make one logging process atomic and thread safe |
| CLogRecord | Holds all the information about a log entry |
| CLogRecordFunctionInfo | Holds information about a log entry function |
| CLogSimpleFormatter | Very simple log formatter logging the severity level, the time and the message |
| CLogSink | Abstract base class for all log sinks |
| CLogTimer | Class that can be used as a stop watch to measure execution time of operations |
| CLogTxtStreamSink | Simple log sink for writing to streams like cout or file It uses the SimpleFormatter for output |
| CMakeString | Class for in-place stream formatting Used for constructs like: |
| CManifestAgent | Class for managing manifest files |
| CManifestClassInfo | Simple class encapsulation parent and class information stored in a "real" class object |
| CMD5StreamBuf | The MD5 hash function |
| CMemoryBlockInfo | Detailed information of used memory within a memory block |
| CMemoryUsage | Memory usage information in kB |
| ▶CMeshFactory | Singleton that allows to load arbitrary meshes from file in different formats |
| CMeshFormatInfo | Provides information for each format including a human readable description (e.g |
| CMeshLoader | |
| CMeshObject | |
| ▶CMetaSerializer | |
| CTypeWithoutObjectAbstractHelper | |
| CTypeWithoutObjectAbstractHelper< T *, true > | |
| CTypeWithoutObjectAbstractHelper< T, true > | |
| CTypeWithoutObjectHelper | |
| CTypeWithoutObjectHelper< T *, true > | |
| CTypeWithoutObjectHelper< T, true > | |
| CMetaTypeDatabase | Database that stores all meta type information and provides additional functions for accessing the database |
| ▶CMethodMeta | Meta information for RPC methods |
| CParameter | |
| CMicroUnit | Units are basic modules of a complex application |
| CMulticastSender | This class acts as a sender for multicast messages |
| CMultiInputDialog | |
| CNameRegistry | Stores aliases for namespaces and allows to resolve local names to global fully qualified names |
| CNearestNeighborInterpolator | 1D nearest neighbor interpolator |
| CNetworkTypeTrait | Trait that specifies the conversion type of a given data type |
| CNetworkTypeTrait< double > | Specialization for double |
| CNetworkTypeTrait< float > | Specialization for float |
| CNormalRandomDistribution | Random distribution for drawing samples from univariate or multivariate normal distributions |
| CNormalRandomDistribution< 1, T > | |
| CNormalRandomGenerator | Random generator for drawing samples from univariate or multivariate normal distributions |
| CNullClass | Marker class for marking an invalid "null" class |
| CNullSetter | "Null-Setter" tag-class where the AccessorSetterPart does nothing |
| CNumericalIstream | Numerical stream adapter that can be assigned to any input stream and allows streaming of numerical values |
| CNumericalOstream | Numerical stream adapter that can be assigned to any output stream and allows streaming of numerical values |
| CObject | The object class acts as a generic base class for classes which should be used with the classFactory |
| COgreSingletonHelper | |
| COgreWidget | |
| COgreWidgetEx | Extended version of OgreWidget that provides default setup of Ogre components (scene manager, light, camera, etc.) and hence provides a ready-to-use playground for 3D rendering |
| Cogzstream | Use igzstream and ogzstream analogously to ifstream and ofstream respectively |
| COpenSSLWrapperMD | Base class for all message digest hash functions |
| CPageViewPart | Special view part for multi-page workbench views |
| CPathPointItem | |
| CPerformanceStatistics | |
| CPerspectiveTabBar | |
| CPerspectiveTabWidget | |
| CPm3dColormap | The default pm3d gnuplot palette (black-blue-red-yellow) |
| CPoint | General point class template |
| CPoint< T, 2 > | Specialization of Point for 2 dimensions with specialized constructors and converters |
| CPoint< T, 3 > | Specialization of Point for 3 dimensions with specialized constructors and converters |
| CPointBase | The base template class of point, which covers the basic functionality of each point |
| CPointVectorObject | |
| CPolygonObject | |
| CPolygonTool | Tool base class for selecting a polygon in the xy-plane of a 3D scene (in a Visualization3DView) |
| CPolygonTool2D | |
| CPolymorphicChannelBuffer | A channel buffer for polymorphic types (classes derived from mira::Object) |
| CPoolAllocator | Provides a pool allocator that is compatible to STL allocators |
| CPose2LineEdit | |
| ▶CPoseTool | Tool base class for selecting a PoseCov2 pose in the xy-plane of a 3D scene (in a Visualization3DView) |
| CInputModeOrientation | |
| CInputModePosition | |
| CPoseTool2D | |
| CPoseVectorTrait | Typetrait that returns the correct vector type, that depends on whether the Eigen-datatypes of the pose need an alignment or not |
| CPoseVectorTrait< Pose3 > | |
| CPoseVectorTrait< PoseCov3 > | |
| ▶CProcess | Encapsulates a process, that was launched from the current process |
| CEnvironment | Holds the environment variables that can be passed to a process |
| ▶CProcessSpawnManager | Implements manager that starts processes and keeps track of them in order to respawn them if required, etc |
| CProcessInfo | |
| ▶CProfiler | The main Profiler class |
| CScope | |
| CProgramOptions | A central singleton class for accessing command line parameters Underlying class is boost::program::options See http://www.boost.org/doc/libs/1_44_0/doc/html/program_options.html Usage: |
| ▶CPropertyEditor | Provides display and editing facilities for property items in the editor |
| CSupportedType | |
| CPropertyHint | A property hint gives optional instructions to the property editor, i.e |
| CPropertyItemEditor | |
| CPropertyManager | The property manager maintains the properties of objects that are added to the manager |
| CPropertyNode | Abstract base class for all derived property node classes |
| CPropertyNodeInfo | |
| CPropertyNodeListener | |
| CPropertyQueryResult | A structure used for returning the complete result of a (remote) property query, including potential info about a thrown exception |
| CPropertyReflector | Base class for all Reflectors that take care of properties |
| CPropertySerializer | A special PropertyReflector that creates a PropertyNode for each reflected property |
| CPropertyTree | Helper class that is able to hold a complete property tree structure |
| CPropertyView | This view part provides an editor/viewer for properties of other views |
| CPropertyViewPage | PropertyViewPage page |
| CProtecteeMixin | Mixin class that can be used to add the Protectee concept used by ScopedAccess<Protectee(, void)> to an existing class |
| CPseudoClass | This is an auxiliary to enable more verbose exception messages |
| CQConsole | An abstract Qt console |
| CQConsolePopupCompleter | Popup Completer class |
| CQtUnit | A unit that processes its dispatcher within Qt's main thread |
| CRadian | Unsigned angle that is represented using radians |
| CRadianBase | Base class for angle classes that represent angles using radians |
| CRandomGenerator | Template class to easily generate random generators using the boost::random distributions and generators |
| CRandomGeneratorSingleton | Singleton class for generating random numbers |
| ▶CRasterTransformation | Map a rectangular area from one raster into another, with an arbitrary transformation (scale, translation, rotation) inbetween |
| CConfiguration | |
| CImpl | Implementation details |
| Citerator | |
| CRecordedChannelInfo | Contains all settings for a recorded channel like compression, codecs,.. |
| CRect | Rect class for defining rectangles |
| CRect< T, 2 > | Specialization for 2D |
| CRect< T, 3 > | Specialization for 3D |
| CRectBase | The base class for rectangles |
| CRectObject | |
| CRectTool3D | Tool base class for selecting a Rect2f rect in the yx-plane of a 3D scene (in a Visualization3DView) |
| CRecursiveMemberReflector | The RecursiveMemberReflector extents the RecursiveMemberReflectorBase class and implements the member() and property() methods of the ReflectorInterface class by calling the appropriate methods of RecursiveMemberReflectorBase |
| CRecursiveMemberReflectorBase | The RecursiveMemberReflectorBase is a base class for all Reflectors that are used to visit the reflect methods of the classes recursively in order to collect information on the members of these classes |
| CRedBlueColormap | A continuous Red-Blue colormap |
| CReflectMemberMeta | Stores meta information for each member |
| ▶CReflectorInterface | This is the public interface of all reflectors that are able to visit a class' reflect() method |
| CReflectState | If 'reflect barriers' are used, each separated reflection block within an object has a separate state (defined by the Reflector) |
| CTag | |
| CRegistrar | A template class that creates a static instance of TRegistrar |
| CRemoteAuthority | A remote authority is located in another framework |
| CRemoteAuthorityPropertyUpdater | |
| CRemoteAuthorityRootPropertyNode | |
| ▶CRemoteConnection | Base class of connections between frameworks |
| CRPCRemoteFinishHandler | RPCHandler for getting notified when an rpc call on server side is finished and the response is ready |
| CRPCRemoteRequestHandler | RPCHandler for sending a rpc call to the server side |
| CSendData | |
| CRemoteConnectionPool | Owner of every RemoteConnection |
| CRemoteConnectionProxy | A proxy object that represents a connection |
| CRemoteIncomingConnection | Connection class for incoming connections |
| ▶CRemoteModule | Manages connections to other remote frameworks |
| CAuthSettings | Contains the authentication settings |
| CRemoteOutgoingConnectionBase | Connection class for outgoing connections |
| CRemoteServer | Server class handling incoming connections from remote frameworks |
| CResourceName | Class for storing/combining/managing resource names consisting of namespaces and names separated by '/' Resource names can be combined and normalized |
| CRigidTransform | This class represents an affine transformation that supports a translation followed by a rotation (a so called rigid transform) |
| CRigidTransform< T, 2 > | Specialization of RigidTransform for 2 dimensions |
| CRigidTransform< T, 3 > | Specialization of RigidTransform for 3 dimensions |
| CRigidTransformBase | Implementation of RigidTransforms with different dimensionality D |
| CRigidTransformCov | This class represents an affine transformation that supports a translation followed by a rotation (a so called rigid transform) |
| CRigidTransformCov< T, 2 > | Specialization of RigidTransformCov for 2 dimensions |
| CRigidTransformCov< T, 3 > | Specialization of RigidTransformCov for 3 dimensions |
| CRootPropertyNode | A special node that acts only as (empty) root node for a property tree |
| CRPCCallDefinition | Stores info required to call an RPC method - service name, method name, arguments |
| ▶CRPCClient | The RPCClient is responsible for handling the client-side of an rpc call |
| CPendingResponse | PendingResponse template class |
| CPendingResponseBase | Interface for PendingResponse |
| CRPCFuture | An RPCFuture is a proxy for the result of an asynchronous RPC call |
| CRPCFuture< JSONRPCResponse > | This is a specialization for JSON RPC calls |
| CRPCFuture< void > | This is a specialization for RPC calls with the return type of void, where the get() method does not return a value |
| CRPCFutureCommon | Wrapper for boost::unique_future that is specialized for RPC processing |
| ▶CRPCHandler | RPCHandler implements an AbstractRPCHandler |
| CInvokerRunnable | |
| CRPCInvoker | Base of all TRPCInvoker classes which are templates to support different RPC backends |
| ▶CRPCManager | This class is for internal use only |
| CRemoteFinishHandler | Handler that must be implemented by the remote module to send RPC responses to a remote server which sent a previous RPC request |
| CRemoteRequestHandler | Handler that must be implemented by the remote module to send RPC requests to a remote server |
| ▶CRPCServer | The RPCServer is responsible for handling the server-side of an rpc call |
| CDeferredInvoker | Stores all necessary information to invoke a previously decoded and prepared RPC call |
| CMethod | Contains all information on a registered RPC method, including the signature of the method |
| ▶CMethodInfo | Contains information on an existing RPC method: the signature of the method, comments, etc |
| CReflectMethodParamsDocumentation | |
| CParameterInfo | Contains information on an RPC method's parameter: name, description |
| CRPCReflector | Special visitor for the reflect() method that visits all method() and interface() calls within the reflect() method to collect the methods and interfaces within the above Service object |
| CServiceInfo | Contains all available information about a single RPC service, including the service' name, its registered methods and all implemented RPC interfaces |
| CRPCSignature | Stores the signature of an RPC method including the methods name and its parameter types |
| CRSAKey | Definition of a RSA key (public or private) |
| CRSASignature | A class for signing and verifying messages using a RSA key pair |
| CSceneQueryTool | |
| CSchmittTriggerHysteresis | Class realizing a Schmitt trigger |
| CScopedAccess | Grants thread-safe access to an object (the Protectee) that should be protected from concurrent access |
| CScopedAccess< Protectee, void > | Specialization for Mutex=void, i.e |
| CScopedAccessBase | Base class for ScopedAccess with external or Protectee-internal mutex |
| CScrollView | ScrollView extends the QAbstractScrollArea by features like automatic scaling of scrollbars, signals when the visible are was moved and so on |
| CSelectionListDialog | A dialog for providing the a list, where the items can be grouped in categories |
| CSerializableException | |
| ▶CSerializer | Is a special reflector that is used for serialization |
| CAObject | Is used to store the type and the address of all previously serialized objects in a map |
| CSerializerFormatMixin | Used by BinarySerializer, defines the binary format in particular for class versioning information: 0 = version numbers are stored inline in binary data when version() is called; 1 = same as version 0, except that version 1 (as all following versions) explicitly stores version number at the beginning of serialized data; 2 = the positions in binary data are fixed where each object part stores its version number (or a placeholder if not versioned [yet]!) |
| CSerializerFormatMixin01Base | |
| CSerializerFormatMixin< BinaryStream, 0, Buffered, StreamType > | |
| CSerializerFormatMixin< BinaryStream, 1, Buffered, StreamType > | |
| CSerializerFormatMixin< BinaryStream, 2, Buffered, StreamType > | |
| ▶CSerialPort | This class acts as a wrapper to boost::asio::serial_port |
| CBaudrate | An internal class for handling the baudrate |
| CServiceCall | |
| CServiceCall< Ret(ARGS...)> | A ServiceCall is a proxy for a specific method of a specific service, providing a functor-like interface to that method, and encapsulation for checking the availability of the service and method (name, signature) |
| CServiceInterfaceHandler | ServiceInterfaceHandler implements a AbstractInterfaceCallbackHandler |
| CServiceLevel | ServiceLevel by channel name |
| CServiceLevelBase | QoS management information for channels |
| CServiceProperty | Use this class instead of a string property whenever your module has a service as property |
| CSetter | Holds a boost::function object to a special setter function that must meet the signature "void method(T)" |
| CSHA1StreamBuf | The SHA1 hash function |
| CSHA256StreamBuf | The SHA256 hash function |
| CSharedAuthority | A wrapper providing locked/shared access to an AbstractAuthority pointer (used by AuthorityManager::getAuthority()) The lifetime of the AbstractAuthority object the pointer points to is ensured as long as one wrapper instance exists that wraps the same AbstractAuthority pointer |
| CSharedLibrary | Class for loading a single shared library |
| CSharedLibraryLoader | Class for loading multiple shared libraries |
| CSignalBinder | Class that provides different slots with different parameters |
| CSignedAngle | Signed angle that is represented using radians |
| CSignedDegree | Signed angle that is represented using degrees |
| CSignedRadian | Signed angle that is represented using radians |
| CSingleSelectionListDialog | A dialog for providing the a list, where the items can be grouped in categories |
| CSingleton | A singleton template class that can be freely configured using policies that control the instantiation, creation, lifetime and thread-safety |
| CSize | Size class for defining sizes with different data types |
| CSize< T, 2 > | Specialization for 2D with special members width() and height() |
| CSize< T, 3 > | Specialization for 3D with special members width(),height() and depth() |
| CSpinBoxDelegate | Delegate for a QTableWidgetItem (or any model-view item for that matter) |
| CSpinlock | A spinlock is similar to a mutex and allows thread synchronization of critical sections |
| CSplashScreen | Widget provides a splash screen that can be shown during application startup |
| CSQLiteCachedQuery | A cached SQLite query object that supports serialization |
| CSQLiteDB | An exception that occurs whenever accessing the SQLite db results in an error |
| CSQLiteQuery | Class representing a result of a SQLite database query |
| CStamped | Mix in for adding a time stamp, an optional frame id and an optional sequence id to data types like Pose, RangeScan, etc |
| CStamped< T * > | Stamped class specialization for polymorphic pointers |
| CStampedDataQueue | Implements a queue where Stamped data can be added |
| CStampedHeader | The common header for all stamped data |
| CStampedPrimitive | Stamped class for primitive types like int, float, etc |
| CStatus | Status entry class |
| CStatusManager | Manages the status of one or multiple modules inheriting from DiagnosticsModule |
| CStreamAccessMixin | Direct stream access |
| CStreamAccessMixin< BinaryStream, true > | Stream access buffered through BinaryBufferOstream, can be used to work around limitations of underlying stream (in particular, missing support of tellp/seekp) |
| CStreamAccessMixinBase | Base for buffered/unbuffered stream access |
| CStripedStorageBase | |
| CStripedStorageBinary | |
| CStripedStorageXML | Stores data sequentially into different files (striped) providing a reliable way to retrieve data later from one of the files even if some of the files are corrupted (e.g |
| CTabularColormap | Base class for tabular color colormaps |
| ▶CTape | A tape is a binary file that contains recorded/serialized data of one or multiple channels |
| CChannelInfo | Information about a channel in a tape |
| CFileInfo | Information about a tape file |
| CHeader | Header containing type and size of the following packet |
| CMessage | Struct for message data in a tape |
| CMessageBlock | Struct for a message block in a tape |
| CMessageIndex | Index entry for a message in the tape |
| CTapeFileDialog | |
| CTapePlayer | Class for playing back tape files |
| CTapePlayerWidget | |
| ▶CTapeRecorder | Class for recording channel data to tape |
| CChannelInfo | Informations about a recorded channel |
| CTapeRecorderConfig | A config that can be passed to the TapeRecorder which contains all settings that should be used for recording |
| ▶CTapeRecorderWidget | The recorder widget |
| CRecordingConfig | |
| ▶CTapeVisitor | Visitor class to inspect tapes by channels and/or time interval |
| Citerator | Iterator to iterate over all messages in all tapes visited by the visitor |
| CMessageInfo | Info about a message entry in a tape |
| CMessageInstance | Instance of a message from a tape |
| CTClass | The TClass object is the implementation of the class class for classes which are available since the corresponding library is loaded |
| CTEigenFormat | Template class wrapping the serializing functionality of eigen to support stream operators using a given format |
| CTEigenFormatReadOnly | Template class wrapping the serializing functionality of eigen to support stream operators using a given format |
| CTemplateClass | The TemplateClass object is the implementation of the Class class for template classes |
| CTextEditAutoCompletion | |
| CTextObject | |
| ▶CThreadMonitor | A thread monitor class |
| CThreadInfo | A thread information type |
| CTime | Wrapper class for boost::posix_time::ptime for adding more functionality to it |
| CTimeOffsetCompensation | |
| CTimeTypesSerializedAsElements | A tag type used as parameter type in humanReadableGetter, humanReadableSetter, humanReadableAccessor to select serialization as individual components (year/month/day etc.) |
| CTitleBar | Base class for all window title bars (EditorPartTitleBar, ViewPartTitleBar) |
| CToHex | Can be used with toString to convert values to their string hex representation |
| CToOct | Can be used with toString to convert values to their string oct representation |
| CTPower | Computes the power base^exponent at compile time |
| CTPower< base, 0 > | |
| CTransformDesc | Describes a path of transformations through the transformation tree |
| CTransformer | A full features transformer class based on GenericTransformer |
| ▶CTransformerBase | Base class for Transformer to decouple base functionality that is type independent from type dependent Transformer class template |
| CChain | Represents a chain or path through the transformation tree from a staring node to the target node containing nodes whose transforms need to be applied inverse and nodes whose transforms need to be applied forward |
| CTransformerNode | Basic reference implementation of an AbstractTransformerNode that stores the transformation data internally in a StampedDataQueue that allows to query the transformation at specific time stamps |
| CTransformProperty | Use this class instead of a string property whenever your module has a transform frame as property |
| CTreeViewFilter | |
| CTRPCInvoker | Invoker that is used to invoke an RPC method call for a special backend |
| ▶CTypedChannelBufferBase | Base class for typed channel buffers |
| CSlot | Typed slot derived from ChannelBufferBase::Slot |
| CTypedDefaultTextVisualizationBase | |
| CTypedPropertyNode | Abstract base class for all typed property nodes |
| CTypedPropertyNodeImpl | Implementation of TypedPropertyNode |
| CTypedPropertyNodeImpl< Accessor< Getter, Setter > > | Implementation of TypedPropertyNode for Accessors, i.e |
| CTypedPropertyNodeImpl< T * > | Implementation of TypedPropertyNode for pointers |
| CTypedPropertyNodeImplGetSetMixin | Partial Implementations of the get/set of TypedPropertyNode specialized for normal classes / for classes that are not copyable |
| CTypedPropertyNodeImplGetSetMixin< T, false > | |
| CTypedPropertyNodeImplGetSetMixinBase | |
| CTypedRemotePropertyNode | Special TypedPropertyNode for remote properties |
| CTypedVoidConstPtr | Same as TypedVoidPtr but const |
| CTypedVoidPtr | Class that allows to maintain type-safety when passing void pointers |
| CTypeMeta | Meta Type information |
| CTypeServiceLevel | ServiceLevel by channel type |
| CUniformRandomGenerator | A random generator that samples random numbers within the interval that is passed to the constructor |
| CUnit | A more complex unit that adds a default timer to the thread dispatcher of the authority that acts as a worker thread (process()) |
| CUnitManager | Class managing micro units and units |
| CUntypedImgConstIterator | Untyped const image iterator, that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| CUntypedImgIterator | Untyped image iterator, that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| CUntypedImgIteratorValue | |
| CVacantClass | The VacantClass object is the implementation of the Class class for classes which are NOT available since the corresponding library is NOT loaded |
| CViewPart | A view is typically used to display information or properties |
| CViewPartTitleBar | |
| ▶CVisualization | Abstract base class for all derived visualizations, namely Visualization3D and Visualization2D |
| CDataConnection | The data structure that is returned by getDataConnection |
| CVisualization2D | Abstract base class for all 2D visualization that are used by Visualization2DView |
| CVisualization2DBasic | Inherit from this class if you want to implement a simple 2D visualization |
| CVisualization2DContainer | |
| ▶CVisualization2DView | 2D view of a scene that may contain different visualization objects which show the actual content of the scene |
| CUI | |
| CVisualization3D | Abstract base class for all 3D visualization that are used by Visualization3DView |
| CVisualization3DBasic | Inherit from this class if you want to implement a simple 3D visualization |
| CVisualization3DContainer | A standalone container for 3D visualizations, similar to Visualization3DView but as lightweight standalone widget instead of a view within the RCP framework |
| CVisualization3DView | 3D view of a scene that may contain different visualization objects which show the actual content of the scene |
| CVisualizationControl | View part for managing (adding, removing and editing properties) visualizations of the currently focused visualization view |
| CVisualizationControlPage | VisualizationControl page |
| CVisualizationObject | |
| ▶CVisualizationRegistry | Stores mappings from type names to Visualization classes of Visualizations that are able to show the data |
| CEntry | |
| CVisualizationText | Abstract base class for all text visualization |
| CVisualizationTextBase | |
| CVisualizationTextBasic | |
| CVisualizationTextItem | |
| CVisualizationTextJSONBase | |
| CVisualizationTextTrace | Abstract base class for a text visualization tracing the data history |
| CVisualizationTextTraceBasic | |
| CVisualizationTool | |
| CVisualizationTool2D | |
| CVisualizationTool3D | |
| CVisualizationView | Abstract base class for 2D, 3D, text and plot visualization views (namely Visualization2DView and Visualization3DView...) |
| CVisualizationViewTransformable | Abstract base class for 2D, 3D, text and plot visualization views (namely Visualization2DView and Visualization3DView...) that support a target frame |
| CWidgetResizeHandler | |
| ▶CWorkbench | |
| CMinimizedDockArea | |
| CMinimizedDockWidgetState | |
| CPerspective | |
| CWorkbenchPart | A workbench part is a component within the workbench |
| CXMemberNotFound_NoDefault | Can be thrown by subclasses of RecursiveMemberReflectorBase to indicate that they did not find a certain member, e.g |
| CXMLDeserializer | Deserializer for serializing objects from XML format |
| ▶CXMLDom | A STL conform wrapper for libxml2 to read XML files as DOM |
| Cattribute_iterator | Iterator for iterating over attributes |
| Cconst_attribute_iterator | Const iterator for iterating over attributes |
| Cconst_data_iterator | Const iterator for iterating over data nodes |
| Cconst_sibling_iterator | Const sibling_iterator for iterating over xml nodes that have the same parent (siblings) |
| Cdata_iterator | Iterator for iterating over data nodes |
| Citerator_base | Base iterator for iterating over xml nodes with the same parent (siblings) |
| CNameSpace | Namespace information of a node |
| Csibling_iterator | Iterator for iterating over xml nodes that have the same parent (sibligs) |
| CXMLDomPreprocessor | Preprocesses XML documents and resolves all special tags like , <if>, <warning> and so on |
| CXMLSerializer | |
| CXMLSerializerTag | Serializer for serializing objects in XML format |
| CXMLVariableValue | Variables defined in xml documents |
| CXRPC | An exception that is thrown by the RPCServer if an RPC call fails |
| ▶Nstd | STL namespace |
| Cis_placeholder< placeholder_template< N > > | |
| Cplaceholder_template |
1.8.14