qos.hpp

Go to the documentation of this file.

// Copyright 2019 Open Source Robotics Foundation, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef RCLCPP__QOS_HPP_
#define RCLCPP__QOS_HPP_
 
#include <string>
 
#include "rclcpp/duration.hpp"
#include "rclcpp/visibility_control.hpp"
#include "rmw/incompatible_qos_events_statuses.h"
#include "rmw/qos_profiles.h"
#include "rmw/types.h"
 
namespace rclcpp
{
 
std::string qos_policy_name_from_kind(rmw_qos_policy_kind_t policy_kind);
 
struct RCLCPP_PUBLIC QoSInitialization
{
  rmw_qos_history_policy_t history_policy;
  size_t depth;
 
  QoSInitialization(rmw_qos_history_policy_t history_policy_arg, size_t depth_arg);
 
  static
  QoSInitialization
  from_rmw(const rmw_qos_profile_t & rmw_qos);
};
 
struct RCLCPP_PUBLIC KeepAll : public rclcpp::QoSInitialization
{
  KeepAll();
};
 
struct RCLCPP_PUBLIC KeepLast : public rclcpp::QoSInitialization
{
  explicit KeepLast(size_t depth);
};
 
class RCLCPP_PUBLIC QoS
{
public:
  explicit
  QoS(
    const QoSInitialization & qos_initialization,
    const rmw_qos_profile_t & initial_profile = rmw_qos_profile_default);
 
 
  // cppcheck-suppress noExplicitConstructor
  QoS(size_t history_depth);  // NOLINT(runtime/explicit): conversion constructor
 
  rmw_qos_profile_t &
  get_rmw_qos_profile();
 
  const rmw_qos_profile_t &
  get_rmw_qos_profile() const;
 
  QoS &
  history(rmw_qos_history_policy_t history);
 
  QoS &
  keep_last(size_t depth);
 
  QoS &
  keep_all();
 
  QoS &
  reliability(rmw_qos_reliability_policy_t reliability);
 
  QoS &
  reliable();
 
  QoS &
  best_effort();
 
  QoS &
  durability(rmw_qos_durability_policy_t durability);
 
 
  QoS &
  durability_volatile();
 
  QoS &
  transient_local();
 
  QoS &
  deadline(rmw_time_t deadline);
 
  QoS &
  deadline(const rclcpp::Duration & deadline);
 
  QoS &
  lifespan(rmw_time_t lifespan);
 
  QoS &
  lifespan(const rclcpp::Duration & lifespan);
 
  QoS &
  liveliness(rmw_qos_liveliness_policy_t liveliness);
 
  QoS &
  liveliness_lease_duration(rmw_time_t liveliness_lease_duration);
 
  QoS &
  liveliness_lease_duration(const rclcpp::Duration & liveliness_lease_duration);
 
  QoS &
  avoid_ros_namespace_conventions(bool avoid_ros_namespace_conventions);
 
private:
  rmw_qos_profile_t rmw_qos_profile_;
};
 
RCLCPP_PUBLIC
bool operator==(const QoS & left, const QoS & right);
RCLCPP_PUBLIC
bool operator!=(const QoS & left, const QoS & right);
 
class RCLCPP_PUBLIC SensorDataQoS : public QoS
{
public:
  explicit
  SensorDataQoS(
    const QoSInitialization & qos_initialization = (
      QoSInitialization::from_rmw(rmw_qos_profile_sensor_data)
  ));
};
 
class RCLCPP_PUBLIC ParametersQoS : public QoS
{
public:
  explicit
  ParametersQoS(
    const QoSInitialization & qos_initialization = (
      QoSInitialization::from_rmw(rmw_qos_profile_parameters)
  ));
};
 
class RCLCPP_PUBLIC ServicesQoS : public QoS
{
public:
  explicit
  ServicesQoS(
    const QoSInitialization & qos_initialization = (
      QoSInitialization::from_rmw(rmw_qos_profile_services_default)
  ));
};
 
class RCLCPP_PUBLIC ParameterEventsQoS : public QoS
{
public:
  explicit
  ParameterEventsQoS(
    const QoSInitialization & qos_initialization = (
      QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)
  ));
};
 
class RCLCPP_PUBLIC SystemDefaultsQoS : public QoS
{
public:
  explicit
  SystemDefaultsQoS(
    const QoSInitialization & qos_initialization = (
      QoSInitialization::from_rmw(rmw_qos_profile_system_default)
  ));
};
 
}  // namespace rclcpp
 
#endif  // RCLCPP__QOS_HPP_