rclcpp
master
C++ ROS Client Library API
|
This header provides the get_node_base_interface() template function. More...
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 |
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< GenericPublisher > | 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. More... | |
template<typename AllocatorT = std::allocator<void>> | |
std::shared_ptr< GenericSubscription > | 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. 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::ostream & | operator<< (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::ostream & | operator<< (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 ¶m) |
Return a json encoded version of the parameter intended for a dict. More... | |
std::ostream & | operator<< (std::ostream &os, const rclcpp::Parameter &pv) |
std::ostream & | operator<< (std::ostream &os, const std::vector< Parameter > ¶meters) |
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::ostream & | operator<< (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::ostream & | operator<< (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::string > | 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. More... | |
std::vector< std::string > | remove_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... | |
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 std::map<rclcpp::CallbackGroup::WeakPtr, rclcpp::node_interfaces::NodeBaseInterface::WeakPtr, std::owner_less<rclcpp::CallbackGroup::WeakPtr> > rclcpp::WeakCallbackGroupsToNodesMap |
using rclcpp::ParameterMap = typedef std::unordered_map<std::string, std::vector<Parameter> > |
A map of fully qualified node names to a list of parameters.
using rclcpp::PublisherOptions = typedef PublisherOptionsWithAllocator<std::allocator<void> > |
using rclcpp::QOSDeadlineOfferedInfo = typedef rmw_offered_deadline_missed_status_t |
using rclcpp::QOSLivelinessChangedInfo = typedef rmw_liveliness_changed_status_t |
using rclcpp::QOSLivelinessLostInfo = typedef rmw_liveliness_lost_status_t |
using rclcpp::QOSMessageLostInfo = typedef rmw_message_lost_status_t |
using rclcpp::QOSRequestedIncompatibleQoSInfo = typedef rmw_requested_qos_incompatible_event_status_t |
using rclcpp::QOSDeadlineRequestedCallbackType = typedef std::function<void (QOSDeadlineRequestedInfo &)> |
using rclcpp::QOSDeadlineOfferedCallbackType = typedef std::function<void (QOSDeadlineOfferedInfo &)> |
using rclcpp::QOSLivelinessChangedCallbackType = typedef std::function<void (QOSLivelinessChangedInfo &)> |
using rclcpp::QOSLivelinessLostCallbackType = typedef std::function<void (QOSLivelinessLostInfo &)> |
using rclcpp::QOSMessageLostCallbackType = typedef std::function<void (QOSMessageLostInfo &)> |
using rclcpp::QOSOfferedIncompatibleQoSCallbackType = typedef std::function<void (QOSOfferedIncompatibleQoSInfo &)> |
using rclcpp::QOSRequestedIncompatibleQoSCallbackType = typedef std::function<void (QOSRequestedIncompatibleQoSInfo &)> |
using rclcpp::QosCallbackResult = typedef rcl_interfaces::msg::SetParametersResult |
using rclcpp::QosCallback = typedef std::function<QosCallbackResult(const rclcpp::QoS &)> |
using rclcpp::Rate = typedef GenericRate<std::chrono::system_clock> |
using rclcpp::WallRate = typedef GenericRate<std::chrono::steady_clock> |
using rclcpp::SubscriptionOptions = typedef SubscriptionOptionsWithAllocator<std::allocator<void> > |
using rclcpp::VoidCallbackType = typedef std::function<void ()> |
using rclcpp::TimerCallbackType = typedef std::function<void (TimerBase &)> |
using rclcpp::WaitSet = typedef 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.
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.
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.
using rclcpp::ThreadSafeWaitSet = typedef rclcpp::WaitSetTemplate< rclcpp::wait_set_policies::ThreadSafeSynchronization, rclcpp::wait_set_policies::DynamicStorage > |
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.
|
strong |
|
strong |
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 |
|
strong |
Used as argument in create_publisher and create_subscriber when intra-process communication is enabled
|
strong |
|
strong |
enum rclcpp::ParameterType : uint8_t |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
std::vector<Context::SharedPtr> rclcpp::get_contexts | ( | ) |
Return a copy of the list of context shared pointers.
This function is thread-safe.
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.
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.
topics_interface | NodeTopicsInterface pointer used in parts of the setup |
topic_name | Topic name |
topic_type | Topic type |
qos | QoS settings |
options | Publisher options. Not all publisher options are currently respected, the only relevant options for this publisher are event_callbacks , use_default_callbacks , and callback_group . |
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.
topics_interface | NodeTopicsInterface pointer used in parts of the setup. |
topic_name | Topic name |
topic_type | Topic type |
qos | QoS settings |
callback | Callback for new messages of serialized form |
options | Publisher options. Not all publisher options are currently respected, the only relevant options for this publisher are event_callbacks , use_default_callbacks , and callback_group . |
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.
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.
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.
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.
MessageT | |
CallbackT | |
AllocatorT | |
CallbackMessageT | |
SubscriptionT | |
MessageMemoryStrategyT | |
NodeT |
node | |
topic_name | |
qos | |
callback | |
options | |
msg_mem_strat |
std::invalid_argument | if topic statistics is enabled and the publish period is less than or equal to zero. |
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.
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
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.
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.
DurationRepT | |
DurationT | |
CallbackT |
period | period to execute callback. This duration must be 0 <= period < nanoseconds::max() |
callback | callback to execute via the timer period |
group | |
node_base | |
node_timers |
std::invalid | argument if either node_base or node_timers are null, or period is negative or too large |
void rclcpp::spin_some | ( | rclcpp::node_interfaces::NodeBaseInterface::SharedPtr | node_ptr | ) |
Create a default single-threaded executor and execute any immediately available work.
[in] | node_ptr | Shared pointer to the node to spin. |
void rclcpp::spin_some | ( | rclcpp::Node::SharedPtr | node_ptr | ) |
void rclcpp::spin | ( | rclcpp::node_interfaces::NodeBaseInterface::SharedPtr | node_ptr | ) |
Create a default single-threaded executor and spin the specified node.
[in] | node_ptr | Shared pointer to the node to spin. |
void rclcpp::spin | ( | rclcpp::Node::SharedPtr | node_ptr | ) |
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) |
||
) |
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) |
||
) |
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.
name | the topic or service name to be validated |
node_name | the name of the node associated with the name |
namespace_ | the namespace of the node associated with the name |
is_service | if true InvalidServiceNameError is thrown instead |
InvalidTopicNameError | if name is invalid and is_service is false |
InvalidServiceNameError | if name is invalid and is_service is true |
std::bad_alloc | if memory cannot be allocated |
RCLError | if an unexpect error occurs |
std::runtime_error | if the topic name is unexpectedly valid or, if the rcl name is invalid or if the rcl namespace is invalid |
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
const FutureReturnCode & | future_return_code | ||
) |
Stream operator for FutureReturnCode.
std::string rclcpp::to_string | ( | const FutureReturnCode & | future_return_code | ) |
String conversion function for FutureReturnCode.
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.
[in] | name | the name of the 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.
[in] | node | the rcl node from which to get the logger name |
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.
rclcpp::exceptions::RCLError | if an unexpected error occurs. |
bool rclcpp::operator== | ( | const NetworkFlowEndpoint & | left, |
const NetworkFlowEndpoint & | right | ||
) |
Check if two NetworkFlowEndpoint instances are equal.
bool rclcpp::operator!= | ( | const NetworkFlowEndpoint & | left, |
const NetworkFlowEndpoint & | right | ||
) |
Check if two NetworkFlowEndpoint instances are not equal.
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
const NetworkFlowEndpoint & | network_flow_endpoint | ||
) |
Streaming helper for NetworkFlowEndpoint.
|
inline |
std::string rclcpp::_to_json_dict_entry | ( | const Parameter & | param | ) |
Return a json encoded version of the parameter intended for a dict.
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
const rclcpp::Parameter & | pv | ||
) |
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
const std::vector< Parameter > & | parameters | ||
) |
ParameterMap rclcpp::parameter_map_from | ( | const rcl_params_t *const | c_params | ) |
Convert parameters from rcl_yaml_param_parser into C++ class instances.
[in] | c_params | C structures containing parameters for multiple nodes. |
InvalidParametersException | if the rcl_params_t is inconsistent or invalid. |
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.
[in] | c_value | C structure containing a value of a parameter. |
InvalidParameterValueException | if the rcl_variant_t is inconsistent or invalid. |
ParameterMap rclcpp::parameter_map_from_yaml_file | ( | const std::string & | yaml_filename | ) |
Get the ParameterMap from a yaml file.
[in] | yaml_filename | full name of the yaml file. |
from | rcl error of rcl_parse_yaml_file() |
std::string rclcpp::to_string | ( | ParameterType | type | ) |
Return the name of a parameter type.
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
ParameterType | type | ||
) |
std::string rclcpp::to_string | ( | const ParameterValue & | type | ) |
Return the value of a parameter as a string.
PublisherFactory rclcpp::create_publisher_factory | ( | const rclcpp::PublisherOptionsWithAllocator< AllocatorT > & | options | ) |
Return a PublisherFactory with functions setup for creating a PublisherT<MessageT, AllocatorT>.
std::string rclcpp::qos_policy_name_from_kind | ( | rmw_qos_policy_kind_t | policy_kind | ) |
Check if two QoS profiles are exactly equal in all policy values.
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:
[in] | publisher_qos | The QoS profile for a publisher. |
[in] | subscription_qos | The QoS profile for a subscription. |
rclcpp::exceptions::QoSCheckCompatibilityException | if an unexpected error occurs. |
const char* rclcpp::qos_policy_kind_to_cstr | ( | const QosPolicyKind & | qpk | ) |
std::ostream& rclcpp::operator<< | ( | std::ostream & | os, |
const QosPolicyKind & | qpk | ||
) |
ScopeExit<Callable> rclcpp::make_scope_exit | ( | Callable | callable | ) |
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>.
[in] | callback | The user-defined callback function to receive a message |
[in] | options | Additional options for the creation of the Subscription. |
[in] | msg_mem_strat | The message memory strategy to use for allocating messages. |
[in] | subscription_topic_stats | Optional stats callback for topic_statistics |
Time rclcpp::operator+ | ( | const rclcpp::Duration & | lhs, |
const rclcpp::Time & | rhs | ||
) |
std::overflow_error | if addition leads to overflow |
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.
[in] | type | The topic type, e.g. "std_msgs/msg/String" |
[in] | typesupport_identifier | Type support identifier, typically "rosidl_typesupport_cpp" |
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.
[in] | type | The topic type, e.g. "std_msgs/msg/String" |
[in] | typesupport_identifier | Type support identifier, typically "rosidl_typesupport_cpp" |
[in] | library | The shared type support library |
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().
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.
bool rclcpp::signal_handlers_installed | ( | ) |
Return true if the signal handlers are installed, otherwise false.
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.
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.
anything | remove_ros_arguments can throw |
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.
[in] | argc | Number of arguments. |
[in] | argv | Argument vector. |
anything | throw_from_rcl_error can throw |
rclcpp::exceptions::RCLError | if the parsing fails |
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().
[in] | context | Optional check for shutdown of this Context. |
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.
[in] | context | Optional to be shutdown |
[in] | reason | Optional string passed to the context shutdown method |
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.
[in] | callback | to be called when the given context is shutdown |
[in] | context | with which to associate the context |
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.
If nullptr is given for the context, then the global context is used, i.e. the context initialized by rclcpp::init().
[in] | nanoseconds | A std::chrono::duration representing how long to sleep for. |
[in] | context | Optional which may interrupt this sleep |
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.
[in] | x | is the first addend. |
[in] | y | is the second addend. |
T | is type of the operands. |
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.
[in] | x | is the first addend. |
[in] | y | is the second addend. |
T | is type of the operands. |
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.
[in] | x | is the minuend. |
[in] | y | is the subtrahend. |
T | is type of the operands. |
x - y
sum is grater than T::max value. 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.
[in] | x | is the minuend. |
[in] | y | is the subtrahend. |
T | is type of the operands. |
x - y
sum is less than T::min value. 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.
[in] | string_in | is the string to be returned |
const char* rclcpp::get_c_string | ( | const std::string & | string_in | ) |
Return the C string from the given std::string.
[in] | string_in | is a std::string |