rclcpp  master
C++ ROS Client Library API
Namespaces | Classes | Typedefs | Enumerations | Functions
rclcpp Namespace Reference

This header provides the get_node_base_interface() template function. More...

Namespaces

 allocator
 
 contexts
 
 detail
 
 exceptions
 
 executors
 
 experimental
 
 function_traits
 
 graph_listener
 
 memory_strategies
 
 memory_strategy
 
 message_memory_strategy
 
 node_interfaces
 
 serialization_traits
 
 strategies
 
 subscription_traits
 
 topic_statistics
 
 type_support
 
 wait_set_policies
 

Classes

struct  AnyExecutable
 
class  AnyServiceCallback
 
class  AnySubscriptionCallback
 
class  AsyncParametersClient
 
class  CallbackGroup
 
class  Client
 
class  ClientBase
 
class  Clock
 
class  ClockQoS
 
class  Context
 Context which encapsulates shared state between nodes and other similar entities. More...
 
class  ContextAlreadyInitialized
 Thrown when init is called on an already initialized context. More...
 
class  Duration
 
class  Event
 
class  Executor
 Coordinate the order and timing of available communication tasks. More...
 
struct  ExecutorOptions
 Options to be passed to the executor constructor. More...
 
class  GenericPublisher
 Publisher for serialized messages whose type is not known at compile time. More...
 
class  GenericRate
 
class  GenericSubscription
 Subscription for serialized messages whose type is not known at compile time. More...
 
class  GenericTimer
 Generic timer. Periodically executes a user-specified callback. More...
 
class  GuardCondition
 A condition that can be waited on in a single wait set and asynchronously triggered. More...
 
class  InitOptions
 Encapsulation of options for initializing rclcpp. More...
 
class  JumpHandler
 
struct  KeepAll
 Use to initialize the QoS with the keep_all history setting. More...
 
struct  KeepLast
 Use to initialize the QoS with the keep_last history setting and the given depth. More...
 
class  LoanedMessage
 
class  Logger
 
class  MessageInfo
 Additional meta data about messages taken from subscriptions. More...
 
class  NetworkFlowEndpoint
 
class  Node
 Node is the single point of entry for creating publishers and subscribers. More...
 
class  NodeOptions
 Encapsulation of options for node initialization. More...
 
class  OnShutdownCallbackHandle
 
class  Parameter
 Structure to store an arbitrary parameter with templated get/set methods. More...
 
struct  ParameterCallbackHandle
 
struct  ParameterEventCallbackHandle
 
class  ParameterEventHandler
 A class used to "handle" (monitor and respond to) changes to parameters. More...
 
class  ParameterEventsFilter
 
class  ParameterEventsQoS
 
class  ParameterService
 
class  ParametersQoS
 
class  ParameterTypeException
 Indicate the parameter type does not match the expected type. More...
 
class  ParameterValue
 Store the type and value of a parameter. More...
 
class  Publisher
 A publisher publishes messages of any type to a topic. More...
 
class  PublisherBase
 
struct  PublisherEventCallbacks
 Contains callbacks for various types of events a Publisher can receive from the middleware. More...
 
struct  PublisherFactory
 Factory with functions used to create a MessageT specific PublisherT. More...
 
struct  PublisherOptionsBase
 Non-templated part of PublisherOptionsWithAllocator<Allocator>. More...
 
struct  PublisherOptionsWithAllocator
 Structure containing optional configuration for Publishers. More...
 
class  QoS
 Encapsulation of Quality of Service settings. More...
 
struct  QoSCheckCompatibleResult
 Result type for checking QoS compatibility. More...
 
class  QOSEventHandler
 
class  QOSEventHandlerBase
 
struct  QoSInitialization
 QoS initialization values, cannot be created directly, use KeepAll or KeepLast instead. More...
 
class  QosOverridingOptions
 Options that are passed in subscription/publisher constructor to specify QoSConfigurability. More...
 
class  RateBase
 
class  RosoutQoS
 
struct  ScopeExit
 
class  SensorDataQoS
 
class  Serialization
 Default implementation to (de)serialize a message by using rmw_(de)serialize. More...
 
class  SerializationBase
 Interface to (de)serialize a message. More...
 
class  SerializedMessage
 Object oriented version of rcl_serialized_message_t with destructor to avoid memory leaks. More...
 
class  Service
 
class  ServiceBase
 
class  ServicesQoS
 
class  Subscription
 Subscription implementation, templated on the type of message this subscription receives. More...
 
class  SubscriptionBase
 
struct  SubscriptionEventCallbacks
 Contains callbacks for non-message events that a Subscription can receive from the middleware. More...
 
struct  SubscriptionFactory
 Factory containing a function used to create a Subscription<MessageT>. More...
 
struct  SubscriptionOptionsBase
 Non-template base class for subscription options. More...
 
struct  SubscriptionOptionsWithAllocator
 Structure containing optional configuration for Subscriptions. More...
 
class  SubscriptionWaitSetMask
 Options used to determine what parts of a subscription get added to or removed from a wait set. More...
 
class  SyncParametersClient
 
class  SystemDefaultsQoS
 
class  Time
 
class  TimerBase
 
class  TimeSource
 
class  TopicEndpointInfo
 
class  UnsupportedEventTypeException
 
class  Waitable
 
class  WaitResult
 Interface for introspecting a wait set after waiting on it. More...
 
class  WaitSetTemplate
 Encapsulates sets of waitable items which can be waited on as a group. More...
 
class  WallTimer
 

Typedefs

typedef std::map< rclcpp::CallbackGroup::WeakPtr, rclcpp::node_interfaces::NodeBaseInterface::WeakPtr, std::owner_less< rclcpp::CallbackGroup::WeakPtr > > WeakCallbackGroupsToNodesMap
 
using ParameterMap = std::unordered_map< std::string, std::vector< Parameter > >
 A map of fully qualified node names to a list of parameters. More...
 
using PublisherOptions = PublisherOptionsWithAllocator< std::allocator< void > >
 
using QOSDeadlineRequestedInfo = rmw_requested_deadline_missed_status_t
 
using QOSDeadlineOfferedInfo = rmw_offered_deadline_missed_status_t
 
using QOSLivelinessChangedInfo = rmw_liveliness_changed_status_t
 
using QOSLivelinessLostInfo = rmw_liveliness_lost_status_t
 
using QOSMessageLostInfo = rmw_message_lost_status_t
 
using QOSOfferedIncompatibleQoSInfo = rmw_offered_qos_incompatible_event_status_t
 
using QOSRequestedIncompatibleQoSInfo = rmw_requested_qos_incompatible_event_status_t
 
using QOSDeadlineRequestedCallbackType = std::function< void(QOSDeadlineRequestedInfo &)>
 
using QOSDeadlineOfferedCallbackType = std::function< void(QOSDeadlineOfferedInfo &)>
 
using QOSLivelinessChangedCallbackType = std::function< void(QOSLivelinessChangedInfo &)>
 
using QOSLivelinessLostCallbackType = std::function< void(QOSLivelinessLostInfo &)>
 
using QOSMessageLostCallbackType = std::function< void(QOSMessageLostInfo &)>
 
using QOSOfferedIncompatibleQoSCallbackType = std::function< void(QOSOfferedIncompatibleQoSInfo &)>
 
using QOSRequestedIncompatibleQoSCallbackType = std::function< void(QOSRequestedIncompatibleQoSInfo &)>
 
using QosCallbackResult = rcl_interfaces::msg::SetParametersResult
 
using QosCallback = std::function< QosCallbackResult(const rclcpp::QoS &)>
 
using Rate = GenericRate< std::chrono::system_clock >
 
using WallRate = GenericRate< std::chrono::steady_clock >
 
using SubscriptionOptions = SubscriptionOptionsWithAllocator< std::allocator< void > >
 
using VoidCallbackType = std::function< void()>
 
using TimerCallbackType = std::function< void(TimerBase &)>
 
using WaitSet = rclcpp::WaitSetTemplate< rclcpp::wait_set_policies::SequentialSynchronization, rclcpp::wait_set_policies::DynamicStorage >
 Most common user configuration of a WaitSet, which is dynamic but not thread-safe. More...
 
template<std::size_t NumberOfSubscriptions, std::size_t NumberOfGuardCondtions, std::size_t NumberOfTimers, std::size_t NumberOfClients, std::size_t NumberOfServices, std::size_t NumberOfWaitables>
using StaticWaitSet = rclcpp::WaitSetTemplate< rclcpp::wait_set_policies::SequentialSynchronization, rclcpp::wait_set_policies::StaticStorage< NumberOfSubscriptions, NumberOfGuardCondtions, NumberOfTimers, NumberOfClients, NumberOfServices, NumberOfWaitables > >
 WaitSet configuration which does not allow changes after construction. More...
 
using ThreadSafeWaitSet = rclcpp::WaitSetTemplate< rclcpp::wait_set_policies::ThreadSafeSynchronization, rclcpp::wait_set_policies::DynamicStorage >
 Like WaitSet, this configuration is dynamic, but is also thread-safe. More...
 

Enumerations

enum  CallbackGroupType { CallbackGroupType::MutuallyExclusive, CallbackGroupType::Reentrant }
 
enum  FutureReturnCode { FutureReturnCode::SUCCESS, FutureReturnCode::INTERRUPTED, FutureReturnCode::TIMEOUT }
 Return codes to be used with spin_until_future_complete. More...
 
enum  IntraProcessBufferType { IntraProcessBufferType::SharedPtr, IntraProcessBufferType::UniquePtr, IntraProcessBufferType::CallbackDefault }
 
enum  IntraProcessSetting { IntraProcessSetting::Enable, IntraProcessSetting::Disable, IntraProcessSetting::NodeDefault }
 Used as argument in create_publisher and create_subscriber. More...
 
enum  EndpointType { EndpointType::Invalid = RMW_ENDPOINT_INVALID, EndpointType::Publisher = RMW_ENDPOINT_PUBLISHER, EndpointType::Subscription = RMW_ENDPOINT_SUBSCRIPTION }
 
enum  ParameterType : uint8_t {
  PARAMETER_NOT_SET = rcl_interfaces::msg::ParameterType::PARAMETER_NOT_SET, PARAMETER_BOOL = rcl_interfaces::msg::ParameterType::PARAMETER_BOOL, PARAMETER_INTEGER = rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER, PARAMETER_DOUBLE = rcl_interfaces::msg::ParameterType::PARAMETER_DOUBLE,
  PARAMETER_STRING = rcl_interfaces::msg::ParameterType::PARAMETER_STRING, PARAMETER_BYTE_ARRAY = rcl_interfaces::msg::ParameterType::PARAMETER_BYTE_ARRAY, PARAMETER_BOOL_ARRAY = rcl_interfaces::msg::ParameterType::PARAMETER_BOOL_ARRAY, PARAMETER_INTEGER_ARRAY = rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER_ARRAY,
  PARAMETER_DOUBLE_ARRAY = rcl_interfaces::msg::ParameterType::PARAMETER_DOUBLE_ARRAY, PARAMETER_STRING_ARRAY = rcl_interfaces::msg::ParameterType::PARAMETER_STRING_ARRAY
}
 
enum  HistoryPolicy { HistoryPolicy::KeepLast = RMW_QOS_POLICY_HISTORY_KEEP_LAST, HistoryPolicy::KeepAll = RMW_QOS_POLICY_HISTORY_KEEP_ALL, HistoryPolicy::SystemDefault = RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT, HistoryPolicy::Unknown = RMW_QOS_POLICY_HISTORY_UNKNOWN }
 
enum  ReliabilityPolicy { ReliabilityPolicy::BestEffort = RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT, ReliabilityPolicy::Reliable = RMW_QOS_POLICY_RELIABILITY_RELIABLE, ReliabilityPolicy::SystemDefault = RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT, ReliabilityPolicy::Unknown = RMW_QOS_POLICY_RELIABILITY_UNKNOWN }
 
enum  DurabilityPolicy { DurabilityPolicy::Volatile = RMW_QOS_POLICY_DURABILITY_VOLATILE, DurabilityPolicy::TransientLocal = RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL, DurabilityPolicy::SystemDefault = RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT, DurabilityPolicy::Unknown = RMW_QOS_POLICY_DURABILITY_UNKNOWN }
 
enum  LivelinessPolicy { LivelinessPolicy::Automatic = RMW_QOS_POLICY_LIVELINESS_AUTOMATIC, LivelinessPolicy::ManualByTopic = RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC, LivelinessPolicy::SystemDefault = RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT, LivelinessPolicy::Unknown = RMW_QOS_POLICY_LIVELINESS_UNKNOWN }
 
enum  QoSCompatibility { QoSCompatibility::Ok = RMW_QOS_COMPATIBILITY_OK, QoSCompatibility::Warning = RMW_QOS_COMPATIBILITY_WARNING, QoSCompatibility::Error = RMW_QOS_COMPATIBILITY_ERROR }
 
enum  TopicStatisticsState { TopicStatisticsState::Enable, TopicStatisticsState::Disable, TopicStatisticsState::NodeDefault }
 
enum  WaitResultKind { Ready, Timeout, Empty }
 Represents the various kinds of results from waiting on a wait set. More...
 

Functions

std::vector< Context::SharedPtr > get_contexts ()
 Return a copy of the list of context shared pointers. More...
 
template<typename ServiceT >
rclcpp::Client< ServiceT >::SharedPtr create_client (std::shared_ptr< node_interfaces::NodeBaseInterface > node_base, std::shared_ptr< node_interfaces::NodeGraphInterface > node_graph, std::shared_ptr< node_interfaces::NodeServicesInterface > node_services, const std::string &service_name, const rmw_qos_profile_t &qos_profile, rclcpp::CallbackGroup::SharedPtr group)
 
template<typename AllocatorT = std::allocator<void>>
std::shared_ptr< GenericPublishercreate_generic_publisher (rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr topics_interface, const std::string &topic_name, const std::string &topic_type, const rclcpp::QoS &qos, const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &options=(rclcpp::PublisherOptionsWithAllocator< AllocatorT >()))
 Create and return a GenericPublisher. More...
 
template<typename AllocatorT = std::allocator<void>>
std::shared_ptr< GenericSubscriptioncreate_generic_subscription (rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr topics_interface, const std::string &topic_name, const std::string &topic_type, const rclcpp::QoS &qos, std::function< void(std::shared_ptr< rclcpp::SerializedMessage >)> callback, const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &options=(rclcpp::SubscriptionOptionsWithAllocator< AllocatorT >()))
 Create and return a GenericSubscription. More...
 
template<typename MessageT , typename AllocatorT = std::allocator<void>, typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>, typename NodeT >
std::shared_ptr< PublisherT > create_publisher (NodeT &node, const std::string &topic_name, const rclcpp::QoS &qos, const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &options=(rclcpp::PublisherOptionsWithAllocator< AllocatorT >()))
 Create and return a publisher of the given MessageT type. More...
 
template<typename MessageT , typename AllocatorT = std::allocator<void>, typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>>
std::shared_ptr< PublisherT > create_publisher (rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &node_parameters, rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr &node_topics, const std::string &topic_name, const rclcpp::QoS &qos, const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &options=(rclcpp::PublisherOptionsWithAllocator< AllocatorT >()))
 Create and return a publisher of the given MessageT type. More...
 
template<typename ServiceT , typename CallbackT >
rclcpp::Service< ServiceT >::SharedPtr create_service (std::shared_ptr< node_interfaces::NodeBaseInterface > node_base, std::shared_ptr< node_interfaces::NodeServicesInterface > node_services, const std::string &service_name, CallbackT &&callback, const rmw_qos_profile_t &qos_profile, rclcpp::CallbackGroup::SharedPtr group)
 
template<typename MessageT , typename CallbackT , typename AllocatorT = std::allocator<void>, typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >, typename NodeT >
std::shared_ptr< SubscriptionT > create_subscription (NodeT &node, const std::string &topic_name, const rclcpp::QoS &qos, CallbackT &&callback, const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &options=(rclcpp::SubscriptionOptionsWithAllocator< AllocatorT >()), typename MessageMemoryStrategyT::SharedPtr msg_mem_strat=(MessageMemoryStrategyT::create_default()))
 Create and return a subscription of the given MessageT type. More...
 
template<typename MessageT , typename CallbackT , typename AllocatorT = std::allocator<void>, typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >>
std::shared_ptr< SubscriptionT > create_subscription (rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &node_parameters, rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr &node_topics, const std::string &topic_name, const rclcpp::QoS &qos, CallbackT &&callback, const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &options=(rclcpp::SubscriptionOptionsWithAllocator< AllocatorT >()), typename MessageMemoryStrategyT::SharedPtr msg_mem_strat=(MessageMemoryStrategyT::create_default()))
 Create and return a subscription of the given MessageT type. More...
 
template<typename CallbackT >
rclcpp::TimerBase::SharedPtr create_timer (std::shared_ptr< node_interfaces::NodeBaseInterface > node_base, std::shared_ptr< node_interfaces::NodeTimersInterface > node_timers, rclcpp::Clock::SharedPtr clock, rclcpp::Duration period, CallbackT &&callback, rclcpp::CallbackGroup::SharedPtr group=nullptr)
 
template<typename NodeT , typename CallbackT >
rclcpp::TimerBase::SharedPtr create_timer (NodeT node, rclcpp::Clock::SharedPtr clock, rclcpp::Duration period, CallbackT &&callback, rclcpp::CallbackGroup::SharedPtr group=nullptr)
 Create a timer with a given clock. More...
 
template<typename DurationRepT , typename DurationT , typename CallbackT >
rclcpp::WallTimer< CallbackT >::SharedPtr create_wall_timer (std::chrono::duration< DurationRepT, DurationT > period, CallbackT callback, rclcpp::CallbackGroup::SharedPtr group, node_interfaces::NodeBaseInterface *node_base, node_interfaces::NodeTimersInterface *node_timers)
 Convenience method to create a timer with node resources. More...
 
void spin_some (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 Create a default single-threaded executor and execute any immediately available work. More...
 
void spin_some (rclcpp::Node::SharedPtr node_ptr)
 
void spin (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 Create a default single-threaded executor and spin the specified node. More...
 
void spin (rclcpp::Node::SharedPtr node_ptr)
 
template<typename FutureT , typename TimeRepT = int64_t, typename TimeT = std::milli>
rclcpp::FutureReturnCode spin_until_future_complete (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, const FutureT &future, std::chrono::duration< TimeRepT, TimeT > timeout=std::chrono::duration< TimeRepT, TimeT >(-1))
 
template<typename NodeT = rclcpp::Node, typename FutureT , typename TimeRepT = int64_t, typename TimeT = std::milli>
rclcpp::FutureReturnCode spin_until_future_complete (std::shared_ptr< NodeT > node_ptr, const FutureT &future, std::chrono::duration< TimeRepT, TimeT > timeout=std::chrono::duration< TimeRepT, TimeT >(-1))
 
std::string expand_topic_or_service_name (const std::string &name, const std::string &node_name, const std::string &namespace_, bool is_service=false)
 Expand a topic or service name and throw if it is not valid. More...
 
std::ostreamoperator<< (std::ostream &os, const FutureReturnCode &future_return_code)
 Stream operator for FutureReturnCode. More...
 
std::string to_string (const FutureReturnCode &future_return_code)
 String conversion function for FutureReturnCode. More...
 
Logger get_logger (const std::string &name)
 Return a named logger. More...
 
Logger get_node_logger (const rcl_node_t *node)
 Return a named logger using an rcl_node_t. More...
 
rcpputils::fs::path get_logging_directory ()
 Get the current logging directory. More...
 
bool operator== (const NetworkFlowEndpoint &left, const NetworkFlowEndpoint &right)
 Check if two NetworkFlowEndpoint instances are equal. More...
 
bool operator!= (const NetworkFlowEndpoint &left, const NetworkFlowEndpoint &right)
 Check if two NetworkFlowEndpoint instances are not equal. More...
 
std::ostreamoperator<< (std::ostream &os, const NetworkFlowEndpoint &network_flow_endpoint)
 Streaming helper for NetworkFlowEndpoint. More...
 
RCLCPP_LOCAL std::string extend_name_with_sub_namespace (const std::string &name, const std::string &sub_namespace)
 
std::string _to_json_dict_entry (const Parameter &param)
 Return a json encoded version of the parameter intended for a dict. More...
 
std::ostreamoperator<< (std::ostream &os, const rclcpp::Parameter &pv)
 
std::ostreamoperator<< (std::ostream &os, const std::vector< Parameter > &parameters)
 
ParameterMap parameter_map_from (const rcl_params_t *const c_params)
 
ParameterValue parameter_value_from (const rcl_variant_t *const c_value)
 
ParameterMap parameter_map_from_yaml_file (const std::string &yaml_filename)
 
std::string to_string (ParameterType type)
 Return the name of a parameter type. More...
 
std::ostreamoperator<< (std::ostream &os, ParameterType type)
 
std::string to_string (const ParameterValue &type)
 Return the value of a parameter as a string. More...
 
template<typename MessageT , typename AllocatorT , typename PublisherT >
PublisherFactory create_publisher_factory (const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &options)
 Return a PublisherFactory with functions setup for creating a PublisherT<MessageT, AllocatorT>. More...
 
std::string qos_policy_name_from_kind (rmw_qos_policy_kind_t policy_kind)
 
bool operator== (const QoS &left, const QoS &right)
 Check if two QoS profiles are exactly equal in all policy values. More...
 
bool operator!= (const QoS &left, const QoS &right)
 
QoSCheckCompatibleResult qos_check_compatible (const QoS &publisher_qos, const QoS &subscription_qos)
 Check if two QoS profiles are compatible. More...
 
const char * qos_policy_kind_to_cstr (const QosPolicyKind &qpk)
 
std::ostreamoperator<< (std::ostream &os, const QosPolicyKind &qpk)
 
template<typename Callable >
ScopeExit< Callable > make_scope_exit (Callable callable)
 
template<typename MessageT , typename CallbackT , typename AllocatorT , typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >>
SubscriptionFactory create_subscription_factory (CallbackT &&callback, const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &options, typename MessageMemoryStrategyT::SharedPtr msg_mem_strat, std::shared_ptr< rclcpp::topic_statistics::SubscriptionTopicStatistics< CallbackMessageT >> subscription_topic_stats=nullptr)
 Return a SubscriptionFactory setup to create a SubscriptionT<MessageT, AllocatorT>. More...
 
Time operator+ (const rclcpp::Duration &lhs, const rclcpp::Time &rhs)
 
std::shared_ptr< rcpputils::SharedLibrary > get_typesupport_library (const std::string &type, const std::string &typesupport_identifier)
 Load the type support library for the given type. More...
 
const rosidl_message_type_support_t * get_typesupport_handle (const std::string &type, const std::string &typesupport_identifier, rcpputils::SharedLibrary &library)
 Extract the type support handle from the library. More...
 
void init (int argc, char const *const argv[], const InitOptions &init_options=InitOptions())
 Initialize communications via the rmw implementation and set up a global signal handler. More...
 
bool install_signal_handlers ()
 Install the global signal handler for rclcpp. More...
 
bool signal_handlers_installed ()
 Return true if the signal handlers are installed, otherwise false. More...
 
bool uninstall_signal_handlers ()
 Uninstall the global signal handler for rclcpp. More...
 
std::vector< std::stringinit_and_remove_ros_arguments (int argc, char const *const argv[], const InitOptions &init_options=InitOptions())
 Initialize communications via the rmw implementation and set up a global signal handler. More...
 
std::vector< std::stringremove_ros_arguments (int argc, char const *const argv[])
 Remove ROS-specific arguments from argument vector. More...
 
bool ok (rclcpp::Context::SharedPtr context=nullptr)
 Check rclcpp's status. More...
 
bool shutdown (rclcpp::Context::SharedPtr context=nullptr, const std::string &reason="user called rclcpp::shutdown()")
 Shutdown rclcpp context, invalidating it for derived entities. More...
 
void on_shutdown (std::function< void()> callback, rclcpp::Context::SharedPtr context=nullptr)
 Register a function to be called when shutdown is called on the context. More...
 
bool sleep_for (const std::chrono::nanoseconds &nanoseconds, rclcpp::Context::SharedPtr context=nullptr)
 Use the global condition variable to block for the specified amount of time. More...
 
template<typename T >
bool add_will_overflow (const T x, const T y)
 Safely check if addition will overflow. More...
 
template<typename T >
bool add_will_underflow (const T x, const T y)
 Safely check if addition will underflow. More...
 
template<typename T >
bool sub_will_overflow (const T x, const T y)
 Safely check if subtraction will overflow. More...
 
template<typename T >
bool sub_will_underflow (const T x, const T y)
 Safely check if subtraction will underflow. More...
 
const char * get_c_string (const char *string_in)
 Return the given string. More...
 
const char * get_c_string (const std::string &string_in)
 Return the C string from the given std::string. More...
 

Detailed Description

This header provides the get_node_base_interface() template function.

This header provides the get_node_waitables_interface() template function.

This header provides the get_node_topics_interface() template function.

This header provides the get_node_timers_interface() template function.

This header provides the get_node_time_source_interface() template function.

This header provides the get_node_services_interface() template function.

This header provides the get_node_parameters_interface() template function.

This header provides the get_node_logging_interface() template function.

This header provides the get_node_graph_interface() template function.

This header provides the get_node_clock_interface() template function.

This function is useful for getting the NodeBaseInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeBaseInterface so long as the class has a method called get_node_base_interface() which returns one.

This function is useful for getting the NodeClockInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeClockInterface so long as the class has a method called get_node_clock_interface() which returns one.

This function is useful for getting the NodeGraphInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeGraphInterface so long as the class has a method called get_node_graph_interface() which returns one.

This function is useful for getting the NodeLoggingInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeLoggingInterface so long as the class has a method called get_node_logging_interface() which returns one.

This function is useful for getting the NodeParametersInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeParametersInterface so long as the class has a method called get_node_parameters_interface() which returns one.

This function is useful for getting the NodeServicesInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeServicesInterface so long as the class has a method called get_node_services_interface() which returns one.

This function is useful for getting the NodeTimeSourceInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeTimeSourceInterface so long as the class has a method called get_node_time_source_interface() which returns one.

This function is useful for getting the NodeTimersInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeTimersInterface so long as the class has a method called get_node_timers_interface() which returns one.

This function is useful for getting the NodeTopicsInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeTopicsInterface so long as the class has a method called get_node_topics_interface() which returns one.

This function is useful for getting the NodeWaitablesInterface pointer from various kinds of Node-like classes.

It's able to get a std::shared_ptr to a NodeWaitablesInterface so long as the class has a method called get_node_waitables_interface() which returns one.

Typedef Documentation

◆ WeakCallbackGroupsToNodesMap

typedef std::map<rclcpp::CallbackGroup::WeakPtr, rclcpp::node_interfaces::NodeBaseInterface::WeakPtr, std::owner_less<rclcpp::CallbackGroup::WeakPtr> > rclcpp::WeakCallbackGroupsToNodesMap

◆ ParameterMap

A map of fully qualified node names to a list of parameters.

◆ PublisherOptions

◆ QOSDeadlineRequestedInfo

◆ QOSDeadlineOfferedInfo

◆ QOSLivelinessChangedInfo

◆ QOSLivelinessLostInfo

◆ QOSMessageLostInfo

◆ QOSOfferedIncompatibleQoSInfo

◆ QOSRequestedIncompatibleQoSInfo

◆ QOSDeadlineRequestedCallbackType

◆ QOSDeadlineOfferedCallbackType

◆ QOSLivelinessChangedCallbackType

◆ QOSLivelinessLostCallbackType

◆ QOSMessageLostCallbackType

◆ QOSOfferedIncompatibleQoSCallbackType

◆ QOSRequestedIncompatibleQoSCallbackType

◆ QosCallbackResult

using rclcpp::QosCallbackResult = typedef rcl_interfaces::msg::SetParametersResult

◆ QosCallback

◆ Rate

◆ WallRate

◆ SubscriptionOptions

◆ VoidCallbackType

using rclcpp::VoidCallbackType = typedef std::function<void ()>

◆ TimerCallbackType

◆ WaitSet

Most common user configuration of a WaitSet, which is dynamic but not thread-safe.

This wait set allows you to add and remove items dynamically, and it will automatically remove items that are let out of scope each time wait() or prune_destroyed_entities() is called.

It will not, however, provide thread-safety for adding and removing entities while waiting.

See also
rclcpp::WaitSetTemplate for API documentation

◆ StaticWaitSet

template<std::size_t NumberOfSubscriptions, std::size_t NumberOfGuardCondtions, std::size_t NumberOfTimers, std::size_t NumberOfClients, std::size_t NumberOfServices, std::size_t NumberOfWaitables>
using rclcpp::StaticWaitSet = typedef rclcpp::WaitSetTemplate< rclcpp::wait_set_policies::SequentialSynchronization, rclcpp::wait_set_policies::StaticStorage< NumberOfSubscriptions, NumberOfGuardCondtions, NumberOfTimers, NumberOfClients, NumberOfServices, NumberOfWaitables > >

WaitSet configuration which does not allow changes after construction.

This wait set requires that you specify all entities at construction, and prevents you from calling the typical add and remove functions. It also requires that you specify how many of each item there will be as a template argument.

It will share ownership of the entities until destroyed, therefore it will prevent the destruction of entities so long as the wait set exists, even if the user lets their copy of the shared pointer to the entity go out of scope.

Since the wait set cannot be mutated, it does not need to be thread-safe.

See also
rclcpp::WaitSetTemplate for API documentation

◆ ThreadSafeWaitSet

Like WaitSet, this configuration is dynamic, but is also thread-safe.

This wait set allows you to add and remove items dynamically, and it will automatically remove items that are let out of scope each time wait() or prune_destroyed_entities() is called.

It will also ensure that adding and removing items explicitly from the wait set is done in a thread-safe way, protecting against concurrent add and deletes, as well as add and deletes during a wait(). This thread-safety comes at some overhead and the use of thread synchronization primitives.

See also
rclcpp::WaitSetTemplate for API documentation

Enumeration Type Documentation

◆ CallbackGroupType

Enumerator
MutuallyExclusive 
Reentrant 

◆ FutureReturnCode

Return codes to be used with spin_until_future_complete.

SUCCESS: The future is complete and can be accessed with "get" without blocking. This does not indicate that the operation succeeded; "get" may still throw an exception. INTERRUPTED: The future is not complete, spinning was interrupted by Ctrl-C or another error. TIMEOUT: Spinning timed out.

Enumerator
SUCCESS 
INTERRUPTED 
TIMEOUT 

◆ IntraProcessBufferType

Used as argument in create_publisher and create_subscriber when intra-process communication is enabled

Enumerator
SharedPtr 

Set the data type used in the intra-process buffer as std::shared_ptr<MessageT>

UniquePtr 

Set the data type used in the intra-process buffer as std::unique_ptr<MessageT>

CallbackDefault 

Set the data type used in the intra-process buffer as the same used in the callback.

◆ IntraProcessSetting

Used as argument in create_publisher and create_subscriber.

Enumerator
Enable 

Explicitly enable intraprocess comm at publisher/subscription level.

Disable 

Explicitly disable intraprocess comm at publisher/subscription level.

NodeDefault 

Take intraprocess configuration from the node.

◆ EndpointType

enum rclcpp::EndpointType
strong
Enumerator
Invalid 
Publisher 
Subscription 

◆ ParameterType

enum rclcpp::ParameterType : uint8_t
Enumerator
PARAMETER_NOT_SET 
PARAMETER_BOOL 
PARAMETER_INTEGER 
PARAMETER_DOUBLE 
PARAMETER_STRING 
PARAMETER_BYTE_ARRAY 
PARAMETER_BOOL_ARRAY 
PARAMETER_INTEGER_ARRAY 
PARAMETER_DOUBLE_ARRAY 
PARAMETER_STRING_ARRAY 

◆ HistoryPolicy

enum rclcpp::HistoryPolicy
strong
Enumerator
KeepLast 
KeepAll 
SystemDefault 
Unknown 

◆ ReliabilityPolicy

Enumerator
BestEffort 
Reliable 
SystemDefault 
Unknown 

◆ DurabilityPolicy

Enumerator
Volatile 
TransientLocal 
SystemDefault 
Unknown 

◆ LivelinessPolicy

Enumerator
Automatic 
ManualByTopic 
SystemDefault 
Unknown 

◆ QoSCompatibility

Enumerator
Ok 
Warning 
Error 

◆ TopicStatisticsState

Represent the state of topic statistics collector. Used as argument in create_subscriber.

Enumerator
Enable 

Explicitly enable topic statistics at subscription level.

Disable 

Explicitly disable topic statistics at subscription level.

NodeDefault 

Take topic statistics state from the node.

◆ WaitResultKind

Represents the various kinds of results from waiting on a wait set.

Enumerator
Ready 
Timeout 
Empty 

Function Documentation

◆ get_contexts()

std::vector<Context::SharedPtr> rclcpp::get_contexts ( )

Return a copy of the list of context shared pointers.

This function is thread-safe.

◆ create_client()

template<typename ServiceT >
rclcpp::Client<ServiceT>::SharedPtr rclcpp::create_client ( std::shared_ptr< node_interfaces::NodeBaseInterface node_base,
std::shared_ptr< node_interfaces::NodeGraphInterface node_graph,
std::shared_ptr< node_interfaces::NodeServicesInterface node_services,
const std::string service_name,
const rmw_qos_profile_t qos_profile,
rclcpp::CallbackGroup::SharedPtr  group 
)

Create a service client with a given type.

◆ create_generic_publisher()

template<typename AllocatorT = std::allocator<void>>
std::shared_ptr<GenericPublisher> rclcpp::create_generic_publisher ( rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr  topics_interface,
const std::string topic_name,
const std::string topic_type,
const rclcpp::QoS qos,
const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()  ) 
)

Create and return a GenericPublisher.

The returned pointer will never be empty, but this function can throw various exceptions, for instance when the message's package can not be found on the AMENT_PREFIX_PATH.

Parameters
topics_interfaceNodeTopicsInterface pointer used in parts of the setup
topic_nameTopic name
topic_typeTopic type
qosQoS settings
optionsPublisher options. Not all publisher options are currently respected, the only relevant options for this publisher are event_callbacks, use_default_callbacks, and callback_group.

◆ create_generic_subscription()

template<typename AllocatorT = std::allocator<void>>
std::shared_ptr<GenericSubscription> rclcpp::create_generic_subscription ( rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr  topics_interface,
const std::string topic_name,
const std::string topic_type,
const rclcpp::QoS qos,
std::function< void(std::shared_ptr< rclcpp::SerializedMessage >)>  callback,
const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()  ) 
)

Create and return a GenericSubscription.

The returned pointer will never be empty, but this function can throw various exceptions, for instance when the message's package can not be found on the AMENT_PREFIX_PATH.

Parameters
topics_interfaceNodeTopicsInterface pointer used in parts of the setup.
topic_nameTopic name
topic_typeTopic type
qosQoS settings
callbackCallback for new messages of serialized form
optionsPublisher options. Not all publisher options are currently respected, the only relevant options for this publisher are event_callbacks, use_default_callbacks, and callback_group.

◆ create_publisher() [1/2]

template<typename MessageT , typename AllocatorT = std::allocator<void>, typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>, typename NodeT >
std::shared_ptr<PublisherT> rclcpp::create_publisher ( NodeT &  node,
const std::string topic_name,
const rclcpp::QoS qos,
const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()  ) 
)

Create and return a publisher of the given MessageT type.

The NodeT type only needs to have a method called get_node_topics_interface() which returns a shared_ptr to a NodeTopicsInterface.

In case options.qos_overriding_options is enabling qos parameter overrides, NodeT must also have a method called get_node_parameters_interface() which returns a shared_ptr to a NodeParametersInterface.

◆ create_publisher() [2/2]

template<typename MessageT , typename AllocatorT = std::allocator<void>, typename PublisherT = rclcpp::Publisher<MessageT, AllocatorT>>
std::shared_ptr<PublisherT> rclcpp::create_publisher ( rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &  node_parameters,
rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr &  node_topics,
const std::string topic_name,
const rclcpp::QoS qos,
const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()  ) 
)

Create and return a publisher of the given MessageT type.

◆ create_service()

template<typename ServiceT , typename CallbackT >
rclcpp::Service<ServiceT>::SharedPtr rclcpp::create_service ( std::shared_ptr< node_interfaces::NodeBaseInterface node_base,
std::shared_ptr< node_interfaces::NodeServicesInterface node_services,
const std::string service_name,
CallbackT &&  callback,
const rmw_qos_profile_t qos_profile,
rclcpp::CallbackGroup::SharedPtr  group 
)

Create a service with a given type.

◆ create_subscription() [1/2]

template<typename MessageT , typename CallbackT , typename AllocatorT = std::allocator<void>, typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >, typename NodeT >
std::shared_ptr<SubscriptionT> rclcpp::create_subscription ( NodeT &  node,
const std::string topic_name,
const rclcpp::QoS qos,
CallbackT &&  callback,
const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()  ),
typename MessageMemoryStrategyT::SharedPtr  msg_mem_strat = (    MessageMemoryStrategyT::create_default()  ) 
)

Create and return a subscription of the given MessageT type.

The NodeT type only needs to have a method called get_node_topics_interface() which returns a shared_ptr to a NodeTopicsInterface, or be a NodeTopicsInterface pointer itself.

In case options.qos_overriding_options is enabling qos parameter overrides, NodeT must also have a method called get_node_parameters_interface() which returns a shared_ptr to a NodeParametersInterface.

Template Parameters
MessageT
CallbackT
AllocatorT
CallbackMessageT
SubscriptionT
MessageMemoryStrategyT
NodeT
Parameters
node
topic_name
qos
callback
options
msg_mem_strat
Returns
the created subscription
Exceptions
std::invalid_argumentif topic statistics is enabled and the publish period is less than or equal to zero.

◆ create_subscription() [2/2]

template<typename MessageT , typename CallbackT , typename AllocatorT = std::allocator<void>, typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >>
std::shared_ptr<SubscriptionT> rclcpp::create_subscription ( rclcpp::node_interfaces::NodeParametersInterface::SharedPtr &  node_parameters,
rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr &  node_topics,
const std::string topic_name,
const rclcpp::QoS qos,
CallbackT &&  callback,
const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &  options = (    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()  ),
typename MessageMemoryStrategyT::SharedPtr  msg_mem_strat = (    MessageMemoryStrategyT::create_default()  ) 
)

Create and return a subscription of the given MessageT type.

See create_subscription().

◆ create_timer() [1/2]

template<typename CallbackT >
rclcpp::TimerBase::SharedPtr rclcpp::create_timer ( std::shared_ptr< node_interfaces::NodeBaseInterface node_base,
std::shared_ptr< node_interfaces::NodeTimersInterface node_timers,
rclcpp::Clock::SharedPtr  clock,
rclcpp::Duration  period,
CallbackT &&  callback,
rclcpp::CallbackGroup::SharedPtr  group = nullptr 
)

Create a timer with a given clock

◆ create_timer() [2/2]

template<typename NodeT , typename CallbackT >
rclcpp::TimerBase::SharedPtr rclcpp::create_timer ( NodeT  node,
rclcpp::Clock::SharedPtr  clock,
rclcpp::Duration  period,
CallbackT &&  callback,
rclcpp::CallbackGroup::SharedPtr  group = nullptr 
)

Create a timer with a given clock.

◆ create_wall_timer()

template<typename DurationRepT , typename DurationT , typename CallbackT >
rclcpp::WallTimer<CallbackT>::SharedPtr rclcpp::create_wall_timer ( std::chrono::duration< DurationRepT, DurationT >  period,
CallbackT  callback,
rclcpp::CallbackGroup::SharedPtr  group,
node_interfaces::NodeBaseInterface node_base,
node_interfaces::NodeTimersInterface node_timers 
)

Convenience method to create a timer with node resources.

Template Parameters
DurationRepT
DurationT
CallbackT
Parameters
periodperiod to execute callback. This duration must be 0 <= period < nanoseconds::max()
callbackcallback to execute via the timer period
group
node_base
node_timers
Returns
Exceptions
std::invalidargument if either node_base or node_timers are null, or period is negative or too large

◆ spin_some() [1/2]

void rclcpp::spin_some ( rclcpp::node_interfaces::NodeBaseInterface::SharedPtr  node_ptr)

Create a default single-threaded executor and execute any immediately available work.

Parameters
[in]node_ptrShared pointer to the node to spin.

◆ spin_some() [2/2]

void rclcpp::spin_some ( rclcpp::Node::SharedPtr  node_ptr)

◆ spin() [1/2]

void rclcpp::spin ( rclcpp::node_interfaces::NodeBaseInterface::SharedPtr  node_ptr)

Create a default single-threaded executor and spin the specified node.

Parameters
[in]node_ptrShared pointer to the node to spin.

◆ spin() [2/2]

void rclcpp::spin ( rclcpp::Node::SharedPtr  node_ptr)

◆ spin_until_future_complete() [1/2]

template<typename FutureT , typename TimeRepT = int64_t, typename TimeT = std::milli>
rclcpp::FutureReturnCode rclcpp::spin_until_future_complete ( rclcpp::node_interfaces::NodeBaseInterface::SharedPtr  node_ptr,
const FutureT &  future,
std::chrono::duration< TimeRepT, TimeT >  timeout = std::chrono::duration<TimeRepT, TimeT>(-1) 
)

◆ spin_until_future_complete() [2/2]

template<typename NodeT = rclcpp::Node, typename FutureT , typename TimeRepT = int64_t, typename TimeT = std::milli>
rclcpp::FutureReturnCode rclcpp::spin_until_future_complete ( std::shared_ptr< NodeT >  node_ptr,
const FutureT &  future,
std::chrono::duration< TimeRepT, TimeT >  timeout = std::chrono::duration<TimeRepT, TimeT>(-1) 
)

◆ expand_topic_or_service_name()

std::string rclcpp::expand_topic_or_service_name ( const std::string name,
const std::string node_name,
const std::string namespace_,
bool  is_service = false 
)

Expand a topic or service name and throw if it is not valid.

This function can be used to "just" validate a topic or service name too, since expanding the topic name is required to fully validate a name.

If the name is invalid, then InvalidTopicNameError is thrown or InvalidServiceNameError if is_service is true.

This function can take any form of a topic or service name, i.e. it does not have to be a fully qualified name. The node name and namespace are used to expand it if necessary while validating it.

Expansion is done with rcl_expand_topic_name. The validation is doen with rcl_validate_topic_name and rmw_validate_full_topic_name, so details about failures can be found in the documentation for those functions.

Parameters
namethe topic or service name to be validated
node_namethe name of the node associated with the name
namespace_the namespace of the node associated with the name
is_serviceif true InvalidServiceNameError is thrown instead
Returns
expanded (and validated) topic name
Exceptions
InvalidTopicNameErrorif name is invalid and is_service is false
InvalidServiceNameErrorif name is invalid and is_service is true
std::bad_allocif memory cannot be allocated
RCLErrorif an unexpect error occurs
std::runtime_errorif the topic name is unexpectedly valid or, if the rcl name is invalid or if the rcl namespace is invalid

◆ operator<<() [1/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
const FutureReturnCode future_return_code 
)

Stream operator for FutureReturnCode.

◆ to_string() [1/3]

std::string rclcpp::to_string ( const FutureReturnCode future_return_code)

String conversion function for FutureReturnCode.

◆ get_logger()

Logger rclcpp::get_logger ( const std::string name)

Return a named logger.

The returned logger's name will include any naming conventions, such as a name prefix. Currently there are no such naming conventions but they may be introduced in the future.

Parameters
[in]namethe name of the logger
Returns
a logger with the fully-qualified name including naming conventions, or
a dummy logger if logging is disabled.

◆ get_node_logger()

Logger rclcpp::get_node_logger ( const rcl_node_t node)

Return a named logger using an rcl_node_t.

This is a convenience function that does error checking and returns the node logger name, or "rclcpp" if it is unable to get the node name.

Parameters
[in]nodethe rcl node from which to get the logger name
Returns
a logger based on the node name, or "rclcpp" if there's an error

◆ get_logging_directory()

rcpputils::fs::path rclcpp::get_logging_directory ( )

Get the current logging directory.

For more details of how the logging directory is determined, see rcl_logging_get_logging_directory.

Returns
the logging directory being used.
Exceptions
rclcpp::exceptions::RCLErrorif an unexpected error occurs.

◆ operator==() [1/2]

bool rclcpp::operator== ( const NetworkFlowEndpoint left,
const NetworkFlowEndpoint right 
)

Check if two NetworkFlowEndpoint instances are equal.

◆ operator!=() [1/2]

bool rclcpp::operator!= ( const NetworkFlowEndpoint left,
const NetworkFlowEndpoint right 
)

Check if two NetworkFlowEndpoint instances are not equal.

◆ operator<<() [2/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
const NetworkFlowEndpoint network_flow_endpoint 
)

Streaming helper for NetworkFlowEndpoint.

◆ extend_name_with_sub_namespace()

RCLCPP_LOCAL std::string rclcpp::extend_name_with_sub_namespace ( const std::string name,
const std::string sub_namespace 
)
inline

◆ _to_json_dict_entry()

std::string rclcpp::_to_json_dict_entry ( const Parameter param)

Return a json encoded version of the parameter intended for a dict.

◆ operator<<() [3/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
const rclcpp::Parameter pv 
)

◆ operator<<() [4/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
const std::vector< Parameter > &  parameters 
)

◆ parameter_map_from()

ParameterMap rclcpp::parameter_map_from ( const rcl_params_t *const  c_params)

Convert parameters from rcl_yaml_param_parser into C++ class instances.

Parameters
[in]c_paramsC structures containing parameters for multiple nodes.
Returns
a map where the keys are fully qualified node names and values a list of parameters.
Exceptions
InvalidParametersExceptionif the rcl_params_t is inconsistent or invalid.

◆ parameter_value_from()

ParameterValue rclcpp::parameter_value_from ( const rcl_variant_t *const  c_value)

Convert parameter value from rcl_yaml_param_parser into a C++ class instance.

Parameters
[in]c_valueC structure containing a value of a parameter.
Returns
an instance of a parameter value
Exceptions
InvalidParameterValueExceptionif the rcl_variant_t is inconsistent or invalid.

◆ parameter_map_from_yaml_file()

ParameterMap rclcpp::parameter_map_from_yaml_file ( const std::string yaml_filename)

Get the ParameterMap from a yaml file.

Parameters
[in]yaml_filenamefull name of the yaml file.
Returns
an instance of a parameter map
Exceptions
fromrcl error of rcl_parse_yaml_file()

◆ to_string() [2/3]

std::string rclcpp::to_string ( ParameterType  type)

Return the name of a parameter type.

◆ operator<<() [5/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
ParameterType  type 
)

◆ to_string() [3/3]

std::string rclcpp::to_string ( const ParameterValue type)

Return the value of a parameter as a string.

◆ create_publisher_factory()

template<typename MessageT , typename AllocatorT , typename PublisherT >
PublisherFactory rclcpp::create_publisher_factory ( const rclcpp::PublisherOptionsWithAllocator< AllocatorT > &  options)

Return a PublisherFactory with functions setup for creating a PublisherT<MessageT, AllocatorT>.

◆ qos_policy_name_from_kind()

std::string rclcpp::qos_policy_name_from_kind ( rmw_qos_policy_kind_t  policy_kind)

◆ operator==() [2/2]

bool rclcpp::operator== ( const QoS left,
const QoS right 
)

Check if two QoS profiles are exactly equal in all policy values.

◆ operator!=() [2/2]

bool rclcpp::operator!= ( const QoS left,
const QoS right 
)

◆ qos_check_compatible()

QoSCheckCompatibleResult rclcpp::qos_check_compatible ( const QoS publisher_qos,
const QoS subscription_qos 
)

Check if two QoS profiles are compatible.

Two QoS profiles are compatible if a publisher and subcription using the QoS policies can communicate with each other.

If any policies have value "system default" or "unknown" then it is possible that compatiblity cannot be determined. In this case, the value QoSCompatility::Warning is set as part of the returned structure.

Example usage:

publisher_qos, subscription_qos);
// QoS not compatible ...
// result.reason contains info about the incompatibility
// QoS may not be compatible ...
// result.reason contains info about the possible incompatibility
}
Parameters
[in]publisher_qosThe QoS profile for a publisher.
[in]subscription_qosThe QoS profile for a subscription.
Returns
Struct with compatiblity set to QoSCompatibility::Ok if the QoS profiles are compatible, or
Struct with compatibility set to QoSCompatibility::Warning if there is a chance the QoS profiles are not compatible, or
Struct with compatibility set to QoSCompatibility::Error if the QoS profiles are not compatible.
Exceptions
rclcpp::exceptions::QoSCheckCompatibilityExceptionif an unexpected error occurs.

◆ qos_policy_kind_to_cstr()

const char* rclcpp::qos_policy_kind_to_cstr ( const QosPolicyKind &  qpk)

◆ operator<<() [6/6]

std::ostream& rclcpp::operator<< ( std::ostream os,
const QosPolicyKind &  qpk 
)

◆ make_scope_exit()

template<typename Callable >
ScopeExit<Callable> rclcpp::make_scope_exit ( Callable  callable)

◆ create_subscription_factory()

template<typename MessageT , typename CallbackT , typename AllocatorT , typename CallbackMessageT = typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename MessageMemoryStrategyT = rclcpp::message_memory_strategy::MessageMemoryStrategy< CallbackMessageT, AllocatorT >>
SubscriptionFactory rclcpp::create_subscription_factory ( CallbackT &&  callback,
const rclcpp::SubscriptionOptionsWithAllocator< AllocatorT > &  options,
typename MessageMemoryStrategyT::SharedPtr  msg_mem_strat,
std::shared_ptr< rclcpp::topic_statistics::SubscriptionTopicStatistics< CallbackMessageT >>  subscription_topic_stats = nullptr 
)

Return a SubscriptionFactory setup to create a SubscriptionT<MessageT, AllocatorT>.

Parameters
[in]callbackThe user-defined callback function to receive a message
[in]optionsAdditional options for the creation of the Subscription.
[in]msg_mem_stratThe message memory strategy to use for allocating messages.
[in]subscription_topic_statsOptional stats callback for topic_statistics

◆ operator+()

Time rclcpp::operator+ ( const rclcpp::Duration lhs,
const rclcpp::Time rhs 
)
Exceptions
std::overflow_errorif addition leads to overflow

◆ get_typesupport_library()

std::shared_ptr<rcpputils::SharedLibrary> rclcpp::get_typesupport_library ( const std::string type,
const std::string typesupport_identifier 
)

Load the type support library for the given type.

Parameters
[in]typeThe topic type, e.g. "std_msgs/msg/String"
[in]typesupport_identifierType support identifier, typically "rosidl_typesupport_cpp"
Returns
A shared library

◆ get_typesupport_handle()

const rosidl_message_type_support_t* rclcpp::get_typesupport_handle ( const std::string type,
const std::string typesupport_identifier,
rcpputils::SharedLibrary &  library 
)

Extract the type support handle from the library.

The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.

Parameters
[in]typeThe topic type, e.g. "std_msgs/msg/String"
[in]typesupport_identifierType support identifier, typically "rosidl_typesupport_cpp"
[in]libraryThe shared type support library
Returns
A type support handle

◆ init()

void rclcpp::init ( int  argc,
char const *const  argv[],
const InitOptions init_options = InitOptions() 
)

Initialize communications via the rmw implementation and set up a global signal handler.

Initializes the global context which is accessible via the function rclcpp::contexts::get_global_default_context(). Also, installs the global signal handlers with the function rclcpp::install_signal_handlers().

See also
rclcpp::Context::init() for more details on arguments and possible exceptions

◆ install_signal_handlers()

bool rclcpp::install_signal_handlers ( )

Install the global signal handler for rclcpp.

This function should only need to be run one time per process. It is implicitly run by rclcpp::init(), and therefore this function does not need to be run manually if rclcpp::init() has already been run.

The signal handler will shutdown all initialized context. It will also interrupt any blocking functions in ROS allowing them react to any changes in the state of the system (like shutdown).

This function is thread-safe.

Returns
true if signal handler was installed by this function, false if already installed.

◆ signal_handlers_installed()

bool rclcpp::signal_handlers_installed ( )

Return true if the signal handlers are installed, otherwise false.

◆ uninstall_signal_handlers()

bool rclcpp::uninstall_signal_handlers ( )

Uninstall the global signal handler for rclcpp.

This function does not necessarily need to be called, but can be used to undo what rclcpp::install_signal_handlers() or rclcpp::init() do with respect to signal handling. If you choose to use it, this function only needs to be run one time. It is implicitly run by rclcpp::shutdown(), and therefore this function does not need to be run manually if rclcpp::shutdown() has already been run.

This function is thread-safe.

Returns
true if signal handler was uninstalled by this function, false if was not installed.

◆ init_and_remove_ros_arguments()

std::vector<std::string> rclcpp::init_and_remove_ros_arguments ( int  argc,
char const *const  argv[],
const InitOptions init_options = InitOptions() 
)

Initialize communications via the rmw implementation and set up a global signal handler.

Additionally removes ROS-specific arguments from the argument vector.

See also
rclcpp::Context::init() for more details on arguments and possible exceptions
Returns
Members of the argument vector that are not ROS arguments.
Exceptions
anythingremove_ros_arguments can throw

◆ remove_ros_arguments()

std::vector<std::string> rclcpp::remove_ros_arguments ( int  argc,
char const *const  argv[] 
)

Remove ROS-specific arguments from argument vector.

Some arguments may not have been intended as ROS arguments. This function populates the arguments in a vector. Since the first argument is always assumed to be a process name, the vector will always contain the process name.

Parameters
[in]argcNumber of arguments.
[in]argvArgument vector.
Returns
Members of the argument vector that are not ROS arguments.
Exceptions
anythingthrow_from_rcl_error can throw
rclcpp::exceptions::RCLErrorif the parsing fails

◆ ok()

bool rclcpp::ok ( rclcpp::Context::SharedPtr  context = nullptr)

Check rclcpp's status.

This may return false for a context which has been shutdown, or for a context that was shutdown due to SIGINT being received by the rclcpp signal handler.

If nullptr is given for the context, then the global context is used, i.e. the context initialized by rclcpp::init().

Parameters
[in]contextOptional check for shutdown of this Context.
Returns
true if shutdown has been called, false otherwise

◆ shutdown()

bool rclcpp::shutdown ( rclcpp::Context::SharedPtr  context = nullptr,
const std::string reason = "user called rclcpp::shutdown()" 
)

Shutdown rclcpp context, invalidating it for derived entities.

If nullptr is given for the context, then the global context is used, i.e. the context initialized by rclcpp::init().

If the global context is used, then the signal handlers are also uninstalled.

This will also cause the "on_shutdown" callbacks to be called.

See also
rclcpp::Context::shutdown()
Parameters
[in]contextOptional to be shutdown
[in]reasonOptional string passed to the context shutdown method
Returns
true if shutdown was successful, false if context was already shutdown

◆ on_shutdown()

void rclcpp::on_shutdown ( std::function< void()>  callback,
rclcpp::Context::SharedPtr  context = nullptr 
)

Register a function to be called when shutdown is called on the context.

If nullptr is given for the context, then the global context is used, i.e. the context initialized by rclcpp::init().

These callbacks are called when the associated Context is shutdown with the Context::shutdown() method. When shutdown by the SIGINT handler, shutdown, and therefore these callbacks, is called asynchronously from the dedicated signal handling thread, at some point after the SIGINT signal is received.

See also
rclcpp::Context::on_shutdown()
Parameters
[in]callbackto be called when the given context is shutdown
[in]contextwith which to associate the context

◆ sleep_for()

bool rclcpp::sleep_for ( const std::chrono::nanoseconds nanoseconds,
rclcpp::Context::SharedPtr  context = nullptr 
)

Use the global condition variable to block for the specified amount of time.

This function can be interrupted early if the associated context becomes invalid due to shutdown() or the signal handler.

See also
rclcpp::Context::sleep_for

If nullptr is given for the context, then the global context is used, i.e. the context initialized by rclcpp::init().

Parameters
[in]nanosecondsA std::chrono::duration representing how long to sleep for.
[in]contextOptional which may interrupt this sleep
Returns
true if the condition variable did not timeout.

◆ add_will_overflow()

template<typename T >
bool rclcpp::add_will_overflow ( const T  x,
const T  y 
)

Safely check if addition will overflow.

The type of the operands, T, should have defined std::numeric_limits<T>::max(), >, < and - operators.

Parameters
[in]xis the first addend.
[in]yis the second addend.
Template Parameters
Tis type of the operands.
Returns
True if the x + y sum is greater than T::max value.

◆ add_will_underflow()

template<typename T >
bool rclcpp::add_will_underflow ( const T  x,
const T  y 
)

Safely check if addition will underflow.

The type of the operands, T, should have defined std::numeric_limits<T>::min(), >, < and - operators.

Parameters
[in]xis the first addend.
[in]yis the second addend.
Template Parameters
Tis type of the operands.
Returns
True if the x + y sum is less than T::min value.

◆ sub_will_overflow()

template<typename T >
bool rclcpp::sub_will_overflow ( const T  x,
const T  y 
)

Safely check if subtraction will overflow.

The type of the operands, T, should have defined std::numeric_limits<T>::max(), >, < and + operators.

Parameters
[in]xis the minuend.
[in]yis the subtrahend.
Template Parameters
Tis type of the operands.
Returns
True if the difference x - y sum is grater than T::max value.

◆ sub_will_underflow()

template<typename T >
bool rclcpp::sub_will_underflow ( const T  x,
const T  y 
)

Safely check if subtraction will underflow.

The type of the operands, T, should have defined std::numeric_limits<T>::min(), >, < and + operators.

Parameters
[in]xis the minuend.
[in]yis the subtrahend.
Template Parameters
Tis type of the operands.
Returns
True if the difference x - y sum is less than T::min value.

◆ get_c_string() [1/2]

const char* rclcpp::get_c_string ( const char *  string_in)

Return the given string.

This function is overloaded to transform any string to C-style string.

Parameters
[in]string_inis the string to be returned
Returns
the given string

◆ get_c_string() [2/2]

const char* rclcpp::get_c_string ( const std::string string_in)

Return the C string from the given std::string.

Parameters
[in]string_inis a std::string
Returns
the C string from the std::string
rclcpp::QoSCompatibility::Warning
@ Warning
rclcpp::QoSCompatibility::Error
@ Error
rclcpp::QoSCheckCompatibleResult
Result type for checking QoS compatibility.
Definition: qos.hpp:288
rclcpp::QoSCheckCompatibleResult::compatibility
QoSCompatibility compatibility
Compatibility result.
Definition: qos.hpp:291
rclcpp::qos_check_compatible
QoSCheckCompatibleResult qos_check_compatible(const QoS &publisher_qos, const QoS &subscription_qos)
Check if two QoS profiles are compatible.