Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 12345]

►Nrclcpp	Versions of rosidl_typesupport_cpp::get_message_type_support_handle that handle adapted types
►Nallocator
CAllocatorDeleter
►Ncontexts
CDefaultContext
►Ndetail
Ccan_be_nullptr
Ccan_be_nullptr< T, std::void_t< decltype(std::declval< T >()==nullptr), decltype(std::declval< T & >()=nullptr)> >
CMessageDeleterHelper
CAnySubscriptionCallbackPossibleTypes	Struct which contains all possible callback signatures, with or without a TypeAdapter.s
CAnySubscriptionCallbackHelper	Template helper to select the variant type based on whether or not MessageT is a TypeAdapter
CAnySubscriptionCallbackHelper< MessageT, AllocatorT, false, false >	Specialization for when MessageT is not a TypeAdapter
CAnySubscriptionCallbackHelper< MessageT, AllocatorT, true, false >	Specialization for when MessageT is a TypeAdapter
CAnySubscriptionCallbackHelper< MessageT, AllocatorT, false, true >	Specialization for when MessageT is a SerializedMessage to exclude duplicated declarations
CFutureAndRequestId
CPublisherQosParametersTraits
CSubscriptionQosParametersTraits
CRMWImplementationSpecificPayload	Mechanism for passing rmw implementation specific settings through the ROS interfaces
CRMWImplementationSpecificPublisherPayload
CRMWImplementationSpecificSubscriptionPayload	Subscription payload that may be rmw implementation specific
CSubscriptionCallbackTypeHelper	Template metaprogramming helper used to resolve the callback argument into a std::function
Cvalue >>
Cvalue >>
Cvalue >>
Cvalue >>
Cvalue >>
Cvalue >>
Ctemplate_contains	Template meta-function that checks if a given T is contained in the list Us
Ctemplate_contains< T, NextT, Us ... >
Ctemplate_contains< T >
Ctemplate_unique	Template meta-function that checks if a given list Ts contains unique types
Ctemplate_unique< NextT, Ts ... >
Ctemplate_unique< T >
CQosParameters
Cassert_type_pair_is_specialized_type_adapter
►Ndynamic_typesupport
CDynamicMessage
CDynamicMessageType
CDynamicMessageTypeBuilder
CDynamicMessageTypeSupport
CDynamicSerializationSupport	Utility wrapper class for rosidl_dynamic_typesupport_serialization_support_t
►Nexceptions
CInvalidNodeError	Thrown when a method is trying to use a node, but it is invalid
CNameValidationError	Thrown when a any kind of name (node, namespace, topic, etc.) is invalid
CInvalidNodeNameError	Thrown when a node name is invalid
CInvalidNamespaceError	Thrown when a node namespace is invalid
CInvalidTopicNameError	Thrown when a topic name is invalid
CInvalidServiceNameError	Thrown when a service name is invalid
CInvalidServiceTypeError
CUnimplementedError
CRCLErrorBase
CRCLError	Created when the return code does not match one of the other specialized exceptions
CRCLBadAlloc	Created when the ret is RCL_RET_BAD_ALLOC
CRCLInvalidArgument	Created when the ret is RCL_RET_INVALID_ARGUMENT
CRCLInvalidROSArgsError	Created when the ret is RCL_RET_INVALID_ROS_ARGS
CUnknownROSArgsError	Thrown when unparsed ROS specific arguments are found
CUnknownTypeError	Thrown when an unknown type is passed
CInvalidEventError	Thrown when an invalid rclcpp::Event object or SharedPtr is encountered
CEventNotRegisteredError	Thrown when an unregistered rclcpp::Event is encountered where a registered one was expected
CMissingGroupNodeException	Thrown when a callback group is missing from the node, when it wants to utilize the group
CInvalidParametersException	Thrown if passed parameters are inconsistent or invalid
CInvalidParameterValueException	Thrown if passed parameter value is invalid
CInvalidParameterTypeException	Thrown if requested parameter type is invalid
CUninitializedStaticallyTypedParameterException	Thrown if user attempts to create an uninitialized statically typed parameter
CParameterAlreadyDeclaredException	Thrown if parameter is already declared
CParameterNotDeclaredException	Thrown if parameter is not declared, e.g. either set or get was called without first declaring
CParameterImmutableException	Thrown if parameter is immutable and therefore cannot be undeclared
CParameterModifiedInCallbackException	Thrown if parameter is modified while in a set callback
CParameterUninitializedException	Thrown when an uninitialized parameter is accessed
CInvalidQosOverridesException	Thrown if the QoS overrides provided aren't valid
CQoSCheckCompatibleException	Thrown if a QoS compatibility check fails
►Nexecutors
CCollectionEntry	Structure to represent a single entity's entry in a collection
CEntityCollection	A collection of entities, indexed by their corresponding handles
CExecutorEntitiesCollection	Represent the total set of entities for a single executor
CExecutorEntitiesCollector	Class to monitor a set of nodes and callback groups for changes in entity membership
CExecutorNotifyWaitable
CMultiThreadedExecutor
CSingleThreadedExecutor	Single-threaded executor implementation
►Nexperimental
►Nbuffers
CBufferImplementationBase
CIntraProcessBufferBase
CIntraProcessBuffer
CTypedIntraProcessBuffer
CRingBufferImplementation	Store elements in a fixed-size, FIFO buffer
►Nexecutors
CEventsExecutor	Events executor implementation
CExecutorEvent
CEventsQueue	This abstract class can be used to implement different types of queues where ExecutorEvent can be stored. The derived classes should choose which underlying container to use and the strategy for pushing and popping events. For example a queue implementation may be bounded or unbounded and have different pruning strategies. Implementations may or may not check the validity of events and decide how to handle the situation where an event is not valid anymore (e.g. a subscription history cache overruns)
CSimpleEventsQueue	This class implements an EventsQueue as a simple wrapper around a std::queue. It does not perform any checks about the size of queue, which can grow unbounded without being pruned. The simplicity of this implementation makes it suitable for optimizing CPU usage
CExecutableList	This class contains subscriptionbase, timerbase, etc. which can be used to run callbacks
CIntraProcessManager	This class performs intra process communication between nodes
CSubscriptionROSMsgIntraProcessBuffer
CSubscriptionIntraProcess
CSubscriptionIntraProcessBase
CSubscriptionIntraProcessBuffer
CTimersManager	This class provides a way for storing and executing timer objects. It provides APIs to suit the needs of different applications and execution models. All public APIs provided by this class are thread-safe
►Nfunction_traits
►Ndetail
Cas_std_function_helper
Cas_std_function_helper< ReturnTypeT, std::tuple< Args ... > >
Ctuple_tail
Ctuple_tail< std::tuple< Head, Tail ... > >
Cfunction_traits
Cfunction_traits< ReturnTypeT(Args ...)>
Cfunction_traits< ReturnTypeT(*)(Args ...)>
Cfunction_traits< ReturnTypeT(ClassT::*)(Args ...) const >
Cfunction_traits< FunctionT & >
Cfunction_traits< FunctionT && >
Carity_comparator
Ccheck_arguments
Csame_arguments
Cas_std_function
►Ngraph_listener
CGraphListenerShutdownError	Thrown when a function is called on a GraphListener that is already shutdown
CNodeAlreadyAddedError	Thrown when a node has already been added to the GraphListener
CNodeNotFoundError	Thrown when the given node is not in the GraphListener
CGraphListener	Notifies many nodes of graph changes by listening in a thread
►Nmemory_strategies
►Nallocator_memory_strategy
CAllocatorMemoryStrategy	Delegate for handling memory allocations while the Executor is executing
►Nmemory_strategy
CMemoryStrategy	Delegate for handling memory allocations while the Executor is executing
►Nmessage_memory_strategy
CMessageMemoryStrategy	Default allocation strategy for messages received by subscriptions
►Nnode_interfaces
►Ndetail
CNodeInterfacesStorage	Stores the interfaces in a tuple, provides constructors, and getters
CNodeInterfacesSupports	Prototype of NodeInterfacesSupports
CNodeInterfacesSupportCheck	Prototype of NodeInterfacesSupportCheck template meta-function
CNodeInterfacesSupportCheck< StorageClassT, NextInterfaceT, RemainingInterfaceTs ... >	Iterating specialization that ensures classes are supported and inherited
CNodeInterfacesSupportCheck< StorageClassT >	Terminating case when there are no more "RemainingInterfaceTs"
CNodeInterfacesSupports< StorageClassT >	Terminating specialization of NodeInterfacesSupports
CNodeBase	Implementation of the NodeBase part of the Node API
CNodeBaseInterface	Pure virtual interface class for the NodeBase part of the Node API
CNodeClock	Implementation of the NodeClock part of the Node API
CNodeClockInterface	Pure virtual interface class for the NodeClock part of the Node API
CNodeGraph	Implementation the NodeGraph part of the Node API
CNodeGraphInterface	Pure virtual interface class for the NodeGraph part of the Node API
CNodeInterfaces	A helper class for aggregating node interfaces
CNodeLogging	Implementation of the NodeLogging part of the Node API
CNodeLoggingInterface	Pure virtual interface class for the NodeLogging part of the Node API
CParameterInfo
CParameterMutationRecursionGuard
CNodeParameters	Implementation of the NodeParameters part of the Node API
CPreSetParametersCallbackHandle
COnSetParametersCallbackHandle
CPostSetParametersCallbackHandle
CNodeParametersInterface	Pure virtual interface class for the NodeParameters part of the Node API
CNodeServices	Implementation of the NodeServices part of the Node API
CNodeServicesInterface	Pure virtual interface class for the NodeServices part of the Node API
CNodeTimeSource	Implementation of the NodeTimeSource part of the Node API
CNodeTimeSourceInterface	Pure virtual interface class for the NodeTimeSource part of the Node API
CNodeTimers	Implementation of the NodeTimers part of the Node API
CNodeTimersInterface	Pure virtual interface class for the NodeTimers part of the Node API
CNodeTopics	Implementation of the NodeTopics part of the Node API
CNodeTopicsInterface	Pure virtual interface class for the NodeTopics part of the Node API
►CNodeTypeDescriptions	Implementation of the NodeTypeDescriptions part of the Node API
CNodeTypeDescriptionsImpl
CNodeTypeDescriptionsInterface	Pure virtual interface class for the NodeTypeDescriptions part of the Node API
CNodeWaitables	Implementation of the NodeWaitables part of the Node API
CNodeWaitablesInterface	Pure virtual interface class for the NodeWaitables part of the Node API
►Nserialization_traits
Cis_serialized_message_class
Cis_serialized_message_class< SerializedMessage >
►Nstrategies
►Nmessage_pool_memory_strategy
►CMessagePoolMemoryStrategy	Completely static memory allocation strategy for messages
CCircularArray
►Nsubscription_traits
Cis_serialized_subscription_argument
Cis_serialized_subscription_argument< SerializedMessage >
Cis_serialized_subscription_argument< std::shared_ptr< SerializedMessage > >
Cis_serialized_subscription
Cis_serialized_callback
Cextract_message_type
Cextract_message_type< std::shared_ptr< MessageT > >
Cextract_message_type< std::unique_ptr< MessageT, Deleter > >
Chas_message_type
►Ntopic_statistics
CSubscriptionTopicStatistics
Ntype_support
►Nwait_set_policies
►Ndetail
CStoragePolicyCommon	Common structure for storage policies, which provides rcl wait set access
CSynchronizationPolicyCommon	Common structure for synchronization policies
►CWritePreferringReadWriteLock	Writer-perferring read-write lock
CReadMutex	Read mutex for the WritePreferringReadWriteLock
CWriteMutex	Write mutex for the WritePreferringReadWriteLock
►CDynamicStorage	WaitSet policy that provides dynamically sized storage
CSubscriptionEntry
CWaitableEntry
CWeakSubscriptionEntry
CWeakWaitableEntry
CSequentialSynchronization	WaitSet policy that explicitly provides no thread synchronization
►CStaticStorage	WaitSet policy that explicitly provides fixed sized storage only
CSubscriptionEntry
CWaitableEntry
CThreadSafeSynchronization	WaitSet policy that provides thread-safe synchronization for the wait set
CAnyExecutable
CService
CAnyServiceCallback
CAnySubscriptionCallback
CCallbackGroup
CClientBase
►CClient
CFutureAndRequestId	A convenient Client::Future and request id pair
CSharedFutureAndRequestId	A convenient Client::SharedFuture and request id pair
CSharedFutureWithRequestAndRequestId	A convenient Client::SharedFutureWithRequest and request id pair
CJumpHandler
►CClock
CImpl
►CClockWaiter
CClockWaiterImpl
►CClockConditionalVariable
CImpl
CContextAlreadyInitialized	Thrown when init is called on an already initialized context
CShutdownCallbackHandle
CContext	Context which encapsulates shared state between nodes and other similar entities
CDuration
CEvent
CPublisherEventCallbacks	Contains callbacks for various types of events a Publisher can receive from the middleware
CSubscriptionEventCallbacks	Contains callbacks for non-message events that a Subscription can receive from the middleware
CUnsupportedEventTypeException
CEventHandlerBase
CEventHandler
CExecutor	Coordinate the order and timing of available communication tasks
CExecutorOptions	Options to be passed to the executor constructor
►CGenericClient
CFutureAndRequestId	A convenient GenericClient::Future and request id pair
CSharedFutureAndRequestId	A convenient GenericClient::SharedFuture and request id pair
CGenericPublisher	Publisher for serialized messages whose type is not known at compile time
CGenericServiceCallback
CGenericService
CGenericSubscription	Subscription for serialized messages whose type is not known at compile time
CGuardCondition	A condition that can be waited on in a single wait set and asynchronously triggered
CInitOptions	Encapsulation of options for initializing rclcpp
Cis_ros_compatible_type
CLoanedMessage
CLogger
CMessageInfo	Additional meta data about messages taken from subscriptions
CNetworkFlowEndpoint
►CNode	Node is the single point of entry for creating publishers and subscribers
CNodeImpl	Internal implementation to provide hidden and API/ABI stable changes to the Node
CTopicEndpointInfo
CNodeOptions	Encapsulation of options for node initialization
CParameter	Structure to store an arbitrary parameter with templated get/set methods
CAsyncParametersClient
CSyncParametersClient
CParameterCallbackHandle
CParameterEventCallbackHandle
►CParameterEventHandler	A class used to "handle" (monitor and respond to) changes to parameters
CCallbacks
CStringPairHash
CParameterEventsFilter
CParameterService
CParameterTypeException	Indicate the parameter type does not match the expected type
CParameterValue	Store the type and value of a parameter
CPublisher	A publisher publishes messages of any type to a topic
CPublisherBase
CPublisherFactory	Factory with functions used to create a MessageT specific PublisherT
CPublisherOptionsBase	Non-templated part of PublisherOptionsWithAllocator<Allocator>
CPublisherOptionsWithAllocator	Structure containing optional configuration for Publishers
CQoSInitialization	QoS initialization values, cannot be created directly, use KeepAll or KeepLast instead
CKeepAll	Use to initialize the QoS with the keep_all history setting
CKeepLast	Use to initialize the QoS with the keep_last history setting and the given depth
CQoS	Encapsulation of Quality of Service settings
CQoSCheckCompatibleResult	Result type for checking QoS compatibility
CClockQoS
CSensorDataQoS
CParametersQoS
CServicesQoS
CParameterEventsQoS
CRosoutQoS
CSystemDefaultsQoS
CBestAvailableQoS
CQosOverridingOptions	Options that are passed in subscription/publisher constructor to specify QoSConfigurability
CRateBase
CRate
CWallRate
CSerializationBase	Interface to (de)serialize a message
CSerialization	Default implementation to (de)serialize a message by using rmw_(de)serialize
CSerializedMessage	Object oriented version of rcl_serialized_message_t with destructor to avoid memory leaks
CServiceBase
CSubscription	Subscription implementation, templated on the type of message this subscription receives
CSubscriptionBase
CContentFilterOptions	Options to configure content filtered topic in the subscription
CSubscriptionFactory	Factory containing a function used to create a Subscription<MessageT>
►CSubscriptionOptionsBase	Non-template base class for subscription options
CTopicStatisticsOptions
CSubscriptionOptionsWithAllocator	Structure containing optional configuration for Subscriptions
CSubscriptionWaitSetMask	Options used to determine what parts of a subscription get added to or removed from a wait set
CTime
►CTimeSource
CNodeState
CTimerInfo
CTimerBase
CGenericTimer	Generic timer. Periodically executes a user-specified callback
CWallTimer
CTypeAdapter	Template structure used to adapt custom, user-defined types to ROS types
Cis_type_adapter	Helper template to determine if a type is a TypeAdapter, false specialization
Cis_type_adapter< TypeAdapter< Ts... > >	Helper template to determine if a type is a TypeAdapter, true specialization
CTypeAdapter< T, void, std::enable_if_t< is_type_adapter< T >::value > >	Identity specialization for TypeAdapter
Cadapt_type	Template metafunction that can make the type being adapted explicit
CImplicitTypeAdapter	Implicit type adapter used as a short hand way to create something with just the custom type
CTypeAdapter< T, void, std::enable_if_t< ImplicitTypeAdapter< T >::is_specialized::value > >	Specialization of TypeAdapter for ImplicitTypeAdapter
CWaitResult	Interface for introspecting a wait set after waiting on it
CWaitSetTemplate	Encapsulates sets of waitable items which can be waited on as a group
CWaitable
CWeakContextsWrapper	Class to manage vector of weak pointers to all created contexts
CExecutorImplementation
CExecutorOptionsImplementation
CSignalHandler	Responsible for managing the SIGINT/SIGTERM signal handling
CClocksState
Nrosidl_typesupport_cpp
Nstd