qos.hpp

Go to the documentation of this file.

// nros-cpp: QoS (Quality of Service) profiles
// Freestanding C++ — no STL required
 
#ifndef NROS_RCLCPP_QOS_HPP
#define NROS_RCLCPP_QOS_HPP
 
#include <stdint.h>
 
// Phase 379 W5 — the deadline / lifespan / lease accessors take and return
// `rclcpp::Duration`, so this header names it. `nros.hpp` includes `qos.hpp`
// before `duration.hpp`, so the dependency is spelled HERE rather than left to
// the umbrella's ordering: a header that names a type must be able to be
// included first.
#include "rclcpp/duration.hpp"
// phase-417 G7 — `NROS_PUBLIC`, for the one C entry point this header
// declares (`qos_policy_kind_to_cstr`, below). Macros only; the file includes
// nothing and compiles freestanding, so it costs this header's
// self-containment nothing.
#include "rclc/visibility_control.h"
// phase-417 stage 6 step A — `rclcpp::detail::refuse` and the
// `NROS_RCLCPP_REFUSE_*` diagnostics, used by `SystemDefaultsQoS` below.
// `log.hpp` includes nothing of ours, so this adds no cycle.
#include "rclcpp/logging.hpp"
// `<type_traits>` is GATED, and this is issue 0112's class one step further
// than step A caught it. Zephyr's minimal libcpp ships exactly THREE headers --
// `cstddef`, `cstdint`, `new` (`zephyr/lib/cpp/minimal/include/`) -- so an
// UNGATED include here made `#include <rclcpp/rclcpp.hpp>` fail to compile on every
// Zephyr C++ image. Step A verified against a SYNTHESISED minimal libcpp that
// happened to provide `<type_traits>`, so the lane stayed green.
//
// `is_qos_arg` exists only to disambiguate `rclcpp::Node`'s create_service
// overloads, and that node type is itself hosted-only, so nothing freestanding
// can reach the predicate.
// This header includes NOTHING, deliberately -- see `is_qos_arg` below.
 
// FFI struct definition — mirrors `nros_cpp_qos_t` in
// nros_cpp_ffi.h. Phase 118.D: guarded by `NROS_CPP_FFI_H`. If
// `nros_cpp_ffi.h` was included earlier (it sets that guard), the
// canonical types are already in scope; otherwise emit local
// definitions so this header stays self-contained for callers that
// don't pull the cbindgen header directly.
//
// The FIELD names below are ABI. `deadline_ms` / `lifespan_ms` /
// `liveliness_lease_ms` are `uint32_t` milliseconds and are mirrored again in
// `rclc/component.h` (issue 0160, gated by `check-ffi-struct-mirrors`). The
// `_ms` suffix on a `QoS` METHOD was renamed in phase-379 W5; the suffix on a
// STRUCT FIELD was not, and must not be — the C ABI carries milliseconds.
#ifndef NROS_CPP_FFI_H
extern "C" {
enum nros_cpp_qos_reliability_t {
    NROS_CPP_QOS_RELIABLE = 0,
    NROS_CPP_QOS_BEST_EFFORT = 1,
    NROS_CPP_QOS_RELIABILITY_SYSTEM_DEFAULT = 2,
    NROS_CPP_QOS_RELIABILITY_UNKNOWN = 3,
};
enum nros_cpp_qos_durability_t {
    NROS_CPP_QOS_VOLATILE = 0,
    NROS_CPP_QOS_TRANSIENT_LOCAL = 1,
    NROS_CPP_QOS_DURABILITY_SYSTEM_DEFAULT = 2,
    NROS_CPP_QOS_DURABILITY_UNKNOWN = 3,
};
enum nros_cpp_qos_history_t {
    NROS_CPP_QOS_KEEP_LAST = 0,
    NROS_CPP_QOS_KEEP_ALL = 1,
    NROS_CPP_QOS_HISTORY_SYSTEM_DEFAULT = 2,
    NROS_CPP_QOS_HISTORY_UNKNOWN = 3,
};
enum nros_cpp_qos_liveliness_t {
    NROS_CPP_QOS_LIVELINESS_NONE = 0,
    NROS_CPP_QOS_LIVELINESS_AUTOMATIC = 1,
    NROS_CPP_QOS_LIVELINESS_MANUAL_BY_TOPIC = 2,
    NROS_CPP_QOS_LIVELINESS_MANUAL_BY_NODE = 3,
    NROS_CPP_QOS_LIVELINESS_UNKNOWN = 4,
};
struct nros_cpp_qos_t {
    enum nros_cpp_qos_reliability_t reliability;
    enum nros_cpp_qos_durability_t durability;
    enum nros_cpp_qos_history_t history;
    enum nros_cpp_qos_liveliness_t liveliness_kind;
    int depth;
    uint32_t deadline_ms;
    uint32_t lifespan_ms;
    uint32_t liveliness_lease_ms;
    uint8_t avoid_ros_namespace_conventions;
    uint8_t tx_express;
};
}
#endif // NROS_CPP_FFI_H
 
namespace rclcpp {
 
// -- Policy enums (phase 379 W5) ------------------------------------------
//
// At NAMESPACE scope and public, under rclcpp's names, because that is where a
// ported node looks for them (`rclcpp::ReliabilityPolicy`, `qos.hpp:34-58`).
// Three of these were PRIVATE members of `QoS` until phase-379 W5, which is why
// the getters had to hand back `int` — a public getter cannot name a private
// type. Ledger: `cpp:ReliabilityPolicy` and its three siblings.
//
// The two rclcpp enumerators we used to decline ARRIVED in phase-444 (issue
// 1437), and the reason each was declined is the reason it is now needed:
//
//   * `SystemDefault` — "defer to the middleware". Declined because nothing
//     DEFERS: the backend is linked at build time (RFC-0036). True of a
//     REQUEST, and a `QoS` is no longer only a request — `get_actual_qos()`
//     hands one back, and a backend CAN report that a policy was never stated.
//   * `Unknown` — declined as "a discovery artefact for a policy read off a
//     remote endpoint, and we do no dynamic discovery". It is not that: it is
//     what `rmw_*_get_actual_qos` owes for a policy the backend looked at and
//     cannot determine, on the LOCAL endpoint. `rmw_vtable.h` has always said
//     so, and until issue 1437 no implementation anywhere wrote one.
//
// What is still declined is `rclcpp::SystemDefaultsQoS` — the all-sentinel
// PRESET, whose two RMWs resolve it to depth 1 and depth 42 (issue 0829).
// A value a backend may REPORT is not a profile a caller may REQUEST, and the
// refusal on that class stands (`NROS_RCLCPP_REFUSE_SYSTEM_DEFAULTS_QOS`).
//
// The enumerators are upstream's and SCOPED (phase-483 W1): one
// `SystemDefault` and one `Unknown` per policy, reached as
// `rclcpp::ReliabilityPolicy::Unknown`. The prefixed spellings
// (`ReliabilityUnknown`, `LivelinessNone`) existed only because these were
// unscoped enums, and the bare `rclcpp::Reliable` form went with them.
 
enum class ReliabilityPolicy : int {
    Reliable = 0,
    BestEffort = 1,
    SystemDefault = 2,
    Unknown = 3,
};
 
enum class DurabilityPolicy : int {
    Volatile = 0,
    TransientLocal = 1,
    SystemDefault = 2,
    Unknown = 3,
};
 
enum class HistoryPolicy : int {
    KeepLast = 0,
    KeepAll = 1,
    SystemDefault = 2,
    Unknown = 3,
};
 
enum class LivelinessPolicy : int {
    SystemDefault = 0,
    Automatic = 1,
    ManualByTopic = 2,
    ManualByNode = 3,
    Unknown = 4,
};
 
class QoS;
 
namespace detail {
 
constexpr uint32_t qos_window_ms(const Duration& d) {
    return d.nanoseconds() <= 0
               ? 0u
               : (d.nanoseconds() > static_cast<int64_t>(UINT32_MAX) * 1000000
                      ? UINT32_MAX
                      : static_cast<uint32_t>((d.nanoseconds() + 999999) / 1000000));
}
 
constexpr Duration qos_window_duration(uint32_t ms) {
    return Duration::from_nanoseconds(static_cast<int64_t>(ms) * 1000000);
}
 
constexpr QoS qos_from_ffi(const nros_cpp_qos_t& f);
 
} // namespace detail
 
class QoS {
  public:
    constexpr QoS()
        : reliability_(ReliabilityPolicy::Reliable), durability_(DurabilityPolicy::Volatile),
          history_(HistoryPolicy::KeepLast), liveliness_(::rclcpp::LivelinessPolicy::SystemDefault),
          depth_(10), deadline_ms_(0), lifespan_ms_(0), liveliness_lease_ms_(0),
          avoid_ros_namespace_conventions_(0), tx_express_(0) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    constexpr QoS(::size_t depth) : QoS() { depth_ = static_cast<int>(depth); }
 
    // -- Chainable setters (match rclcpp fluent API) --
 
    constexpr QoS& reliable() {
        reliability_ = ReliabilityPolicy::Reliable;
        return *this;
    }
 
    constexpr QoS& best_effort() {
        reliability_ = ReliabilityPolicy::BestEffort;
        return *this;
    }
 
    constexpr QoS& transient_local() {
        durability_ = DurabilityPolicy::TransientLocal;
        return *this;
    }
 
    constexpr QoS& durability_volatile() {
        durability_ = DurabilityPolicy::Volatile;
        return *this;
    }
 
    constexpr QoS& keep_last(int depth) {
        history_ = HistoryPolicy::KeepLast;
        depth_ = depth;
        return *this;
    }
 
    constexpr QoS& keep_all() {
        history_ = HistoryPolicy::KeepAll;
        return *this;
    }
 
    constexpr QoS& deadline(const Duration& d) {
        deadline_ms_ = detail::qos_window_ms(d);
        return *this;
    }
 
    constexpr QoS& lifespan(const Duration& d) {
        lifespan_ms_ = detail::qos_window_ms(d);
        return *this;
    }
 
    constexpr QoS& liveliness(LivelinessPolicy kind) {
        liveliness_ = kind;
        return *this;
    }
 
    constexpr QoS& liveliness_lease_duration(const Duration& d) {
        liveliness_lease_ms_ = detail::qos_window_ms(d);
        return *this;
    }
 
    constexpr QoS& avoid_ros_namespace_conventions(bool on) {
        avoid_ros_namespace_conventions_ = on ? 1 : 0;
        return *this;
    }
 
    constexpr QoS& tx_express(bool on) {
        tx_express_ = on ? 1 : 0;
        return *this;
    }
 
    // -- Predefined profiles (match rclcpp named constructors) --
    //
    // phase-428 W10 — DECLARED here, DEFINED below from `rclcpp::detail::qos_table`,
    // which is the one place this header spells a profile's fields. Until W10
    // these three carried their own literals AND the `rclcpp::*QoS` classes at
    // the bottom of the file carried a second, independent set: `sensor_data`
    // and `services_default` were each written twice inside ONE header, with
    // nothing asserting they agreed. That is the hand-mirror class
    // (issues 0088 / 0160 / 0245) at file scope.
 
    static constexpr QoS default_profile();
 
    static constexpr QoS sensor_data();
 
    static constexpr QoS services();
 
    // -- Accessors --
 
    constexpr ReliabilityPolicy reliability() const { return reliability_; }
    constexpr DurabilityPolicy durability() const { return durability_; }
    constexpr HistoryPolicy history() const { return history_; }
    constexpr LivelinessPolicy liveliness() const { return liveliness_; }
    constexpr int depth() const { return depth_; }
    constexpr Duration deadline() const { return detail::qos_window_duration(deadline_ms_); }
    constexpr Duration lifespan() const { return detail::qos_window_duration(lifespan_ms_); }
    constexpr Duration liveliness_lease_duration() const {
        return detail::qos_window_duration(liveliness_lease_ms_);
    }
    constexpr bool avoid_ros_namespace_conventions() const {
        return avoid_ros_namespace_conventions_ != 0;
    }
    constexpr bool tx_express() const { return tx_express_ != 0; }
 
  private:
    // issue 1437 — the ONE function allowed to write these directly.
    //
    // `qos_from_ffi` builds the profile a backend GRANTED, and a grant can
    // state `ReliabilityPolicy::Unknown` / `HistoryPolicy::SystemDefault` / ... which NO
    // public setter can produce: the setters are `reliable()`,
    // `best_effort()`, `keep_last(n)` — the vocabulary of a REQUEST, and a
    // request may not carry a sentinel. Adding enum-taking setters to reach
    // them would hand every caller a way to ask for one, which is the refusal
    // `NROS_RCLCPP_REFUSE_SYSTEM_DEFAULTS_QOS` exists to keep. A friend for
    // the read-back direction alone keeps both properties.
    friend constexpr QoS detail::qos_from_ffi(const nros_cpp_qos_t& f);
 
    // The private members keep their `_ms_` spelling: they hold exactly what
    // the C ABI carries (`uint32_t` milliseconds), and renaming them would say
    // the storage changed when only the accessors did.
    ReliabilityPolicy reliability_;
    DurabilityPolicy durability_;
    HistoryPolicy history_;
    LivelinessPolicy liveliness_;
    int depth_;
    uint32_t deadline_ms_;
    uint32_t lifespan_ms_;
    uint32_t liveliness_lease_ms_;
    uint8_t avoid_ros_namespace_conventions_;
    uint8_t tx_express_;
};
 
// ============================================================================
// phase-417 G6 — profile comparison. `rclcpp::operator==(const QoS&, const QoS&)`
// ============================================================================
//
// FREE functions, as upstream's are, and written from the PUBLIC accessors —
// every one of the ten members has one, so no `friend` is needed and the
// comparison stays a thing a reader can check against the accessor list.
//
// TEN hand-written comparisons rather than `= default`. `operator==() =
// default` is C++20 and this surface's floor is `cxx_std_17`
// (`packages/api/nros-cpp/CMakeLists.txt` — `target_compile_features(
// nros-cpp-headers INTERFACE cxx_std_17)`), so the defaulted form would not
// compile for the targets this header exists to serve. Still `constexpr`,
// still no allocator, still no exceptions.
//
// Rust's `QoSProfile` derives `PartialEq, Eq` and has had this for nothing
// since it existed; the ledger row `cpp:operator==` recorded the asymmetry as
// having no platform reason, and it did not.
//
// The three time windows are compared through `Duration::nanoseconds()`: the
// storage is milliseconds and the conversion is exact in both directions
// (`detail::qos_window_duration`).
 
constexpr bool operator==(const QoS& left, const QoS& right) {
    return left.reliability() == right.reliability() && left.durability() == right.durability() &&
           left.history() == right.history() && left.liveliness() == right.liveliness() &&
           left.depth() == right.depth() &&
           left.deadline().nanoseconds() == right.deadline().nanoseconds() &&
           left.lifespan().nanoseconds() == right.lifespan().nanoseconds() &&
           left.liveliness_lease_duration().nanoseconds() ==
               right.liveliness_lease_duration().nanoseconds() &&
           left.avoid_ros_namespace_conventions() == right.avoid_ros_namespace_conventions() &&
           left.tx_express() == right.tx_express();
}
 
constexpr bool operator!=(const QoS& left, const QoS& right) {
    return !(left == right);
}
 
// ============================================================================
// phase-417 G7 — naming a QoS policy
// ============================================================================
 
extern "C" NROS_PUBLIC const char* rclc_qos_policy_kind_to_cstr(uint32_t policy);
 
inline const char* qos_policy_kind_to_cstr(uint32_t policy) {
    return rclc_qos_policy_kind_to_cstr(policy);
}
 
namespace detail {
 
// --- THE C++ QoS profile table (phase-428 W10) -------------------------------
//
// Every named profile the C++ surface offers is spelled HERE and nowhere else.
// `rclcpp::QoS`'s three named statics and all six concrete `rclcpp::*QoS` classes
// are defined by calling into this block; none of them restates a policy.
//
// Why a table and not a hand copy per class: W10 exists because upstream's 7
// profiles were transcribed in four places across the repo — this header,
// `nros-rmw/src/traits.rs`, `nros/src/lib.rs` and `nros-rmw-abi/.../
// rmw_entity.h` — about 26 constants for a 7-row table, with no gate binding
// them. `QOS_PROFILE_PARAMETER_EVENTS` is the proof: `KeepAll, 0` in Rust under
// a comment claiming it matched `rmw_qos_profile_parameter_events`, which is
// `KEEP_LAST, 1000`. This header had the same profile right, which is exactly
// what an ungated mirror looks like until the day it is not.
//
// This block cannot CONSUME the cross-language SSoT. The C spellings in
// `rmw_entity.h` are `((rmw_qos_profile_t){...})` compound literals, which are
// C99 and not standard C++, over a struct whose field types differ from
// `nros_cpp_qos_t`'s; and `qos.hpp` is deliberately self-contained and
// freestanding (see issue 0112 at the top of this file), so it cannot take a
// dependency on a build-generated header either. What the table DOES buy is
// that the C++ side has ONE row per profile for a cross-language gate to read,
// instead of nine constructor bodies to parse.
//
// phase-454 W1 collected on that. `scripts/check-qos-profile-ssot.py` now
// EVALUATES these rows — the ctor supplies the base profile and each chained
// call applies its one effect — and compares every field against
// `QoSProfile::QOS_PROFILE_*`. So the table is bound after all; what it is not
// is DERIVED, which is the weaker of the two and the strongest available to a
// freestanding header. A `.setter()` the gate does not model is a hard failure
// there, not a skipped field.
//
// Values read 2026-09-05 against ROS 2 Humble as installed:
//   /opt/ros/humble/include/rmw/rmw/qos_profiles.h              :25,38,51,64,77,90
//   /opt/ros/humble/include/rcl/rcl/logging_rosout.h            :36
//   /opt/ros/humble/include/rclcpp/rclcpp/qos.hpp               :371-500
//
// Three fields are identical in EVERY upstream profile and are therefore folded
// into `QoS`'s default constructor rather than spelled per row:
//   * `avoid_ros_namespace_conventions` is `false` upstream, `0` here.
//   * liveliness is `RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT` upstream, and
//     `rclcpp::QoS` now defaults to `LivelinessPolicy::SystemDefault`, which is our spelling of
//     that sentinel. It defaulted to `LivelinessAutomatic` — "what every
//     reference RMW folds that sentinel to" — under a
//     `nros-qos-mirror-deviation` record whose own reason was that this
//     surface and `nros-c`'s "move together with the C ABI or not at all".
//     They moved together (issue 1329): this constructor, `nros-c`'s
//     `NROS_QOS_*` statics and (until phase-492 W4) `component.h`'s
//     `rclc_c_qos_default()`.
//
//     The forcing argument is issue 1329's per-backend QoS mask. XRCE honours
//     no liveliness, so an AUTOMATIC default would have made
//     `required_policies()` demand `LIVELINESS_AUTOMATIC` and refuse every C++
//     default profile on that backend — over a policy upstream leaves unset
//     and the application never asked for. A caller that wants automatic
//     liveliness states `.liveliness(rclcpp::LivelinessPolicy::Automatic)`.
//
//   * deadline and the liveliness lease are `RMW_QOS_*_DEFAULT` (infinite)
//     upstream and `0` here, which `qos_window_ms` above documents as infinite.
//
// `rmw_qos_profile_system_default` has NO row: every one of its fields is a
// sentinel, so no value could be right. `rclcpp::SystemDefaultsQoS` refuses at
// compile time instead — see the class below.
struct qos_table {
    static constexpr QoS default_profile() { return QoS(); }
 
    static constexpr QoS sensor_data() { return QoS().best_effort().keep_last(5); }
 
    static constexpr QoS services_default() { return QoS().reliable().keep_last(10); }
 
    static constexpr QoS parameters() { return QoS().reliable().keep_last(1000); }
 
    static constexpr QoS parameter_events() { return QoS().reliable().keep_last(1000); }
 
    static constexpr QoS rosout() {
        return QoS().reliable().transient_local().keep_last(1000).lifespan(
            ::rclcpp::Duration::from_nanoseconds(10000000000LL));
    }
 
    static constexpr QoS clock() { return QoS().best_effort().keep_last(1); }
};
 
constexpr nros_cpp_qos_t qos_to_ffi(const QoS& qos) {
    nros_cpp_qos_t f{};
    f.reliability = static_cast<nros_cpp_qos_reliability_t>(qos.reliability());
    f.durability = static_cast<nros_cpp_qos_durability_t>(qos.durability());
    f.history = static_cast<nros_cpp_qos_history_t>(qos.history());
    f.liveliness_kind = static_cast<nros_cpp_qos_liveliness_t>(qos.liveliness());
    f.depth = qos.depth();
    // The FFI FIELDS are milliseconds and keep their `_ms` names; only the
    // accessors changed. `qos_window_ms` is the exact inverse of the
    // `Duration` the getter built, so this round-trip loses nothing.
    f.deadline_ms = qos_window_ms(qos.deadline());
    f.lifespan_ms = qos_window_ms(qos.lifespan());
    f.liveliness_lease_ms = qos_window_ms(qos.liveliness_lease_duration());
    f.avoid_ros_namespace_conventions = qos.avoid_ros_namespace_conventions() ? 1 : 0;
    f.tx_express = qos.tx_express() ? 1 : 0;
    return f;
}
 
constexpr QoS qos_all_unknown() {
    nros_cpp_qos_t f{};
    f.reliability = static_cast<nros_cpp_qos_reliability_t>(ReliabilityPolicy::Unknown);
    f.durability = static_cast<nros_cpp_qos_durability_t>(DurabilityPolicy::Unknown);
    f.history = static_cast<nros_cpp_qos_history_t>(HistoryPolicy::Unknown);
    f.liveliness_kind = static_cast<nros_cpp_qos_liveliness_t>(LivelinessPolicy::Unknown);
    f.depth = 0;
    return qos_from_ffi(f);
}
 
constexpr QoS qos_from_ffi(const nros_cpp_qos_t& f) {
    QoS q;
    q.reliability_ = static_cast<ReliabilityPolicy>(f.reliability);
    q.durability_ = static_cast<DurabilityPolicy>(f.durability);
    q.history_ = static_cast<HistoryPolicy>(f.history);
    q.liveliness_ = static_cast<LivelinessPolicy>(f.liveliness_kind);
    q.depth_ = f.depth;
    q.deadline_ms_ = f.deadline_ms;
    q.lifespan_ms_ = f.lifespan_ms;
    q.liveliness_lease_ms_ = f.liveliness_lease_ms;
    q.avoid_ros_namespace_conventions_ = f.avoid_ros_namespace_conventions;
    q.tx_express_ = f.tx_express;
    return q;
}
 
} // namespace detail
 
// phase-428 W10 — the three named statics declared on `QoS`, defined from the
// one table. Out of line because the table needs a COMPLETE `QoS` and these are
// members of it; `constexpr` implies `inline`, so this is still header-only and
// still usable in the `static_assert`s and default arguments that call it.
constexpr QoS QoS::default_profile() {
    return detail::qos_table::default_profile();
}
constexpr QoS QoS::sensor_data() {
    return detail::qos_table::sensor_data();
}
constexpr QoS QoS::services() {
    return detail::qos_table::services_default();
}
 
} // namespace rclcpp
 
// ============================================================================
// rclcpp:: — the ROS 2 spelling of the QoS surface (RFC-0089 stage 6, step A)
// ============================================================================
//
// Moved here from `nros/rclcpp_compat.hpp`, which no longer exists as a
// separate surface: RFC-0089 §"Naming: replace, with alias as the migration
// step" makes the ROS 2 spelling a first-class name declared by the API header
// that owns the concept. Step B, retiring the in-tree `nros::QoS` spelling,
// landed in phase-483 W1.
//
// Everything below is freestanding-safe — `constexpr` classes over `rclcpp::QoS`
// and one `<type_traits>` predicate — so a `no_std` C++ build gets the ROS 2
// QoS vocabulary too, which the hosted-STL shim could never offer it.
 
namespace rclcpp {
 
namespace detail {
 
template <typename F> struct qos_arg_strip {
    typedef F type;
};
template <typename F> struct qos_arg_strip<F&> {
    typedef F type;
};
template <typename F> struct qos_arg_strip<const F&> {
    typedef F type;
};
template <typename F> struct qos_arg_strip<const F> {
    typedef F type;
};
 
template <typename F> class is_qos_arg {
    typedef char yes_t[1];
    typedef char no_t[2];
    // Declared, never defined: both calls live in `sizeof`, which does not
    // evaluate its operand.
    static yes_t& probe(const ::rclcpp::QoS*);
    static no_t& probe(...);
    static typename qos_arg_strip<F>::type* arg();
 
  public:
    static const bool value = sizeof(probe(arg())) == sizeof(yes_t);
};
 
} // namespace detail
 
// --- Named QoS profiles (RFC-0089 W3.f; bound to one table, phase-428 W10) ---
//
// Each class below is a NAME for a row of `rclcpp::detail::qos_table`, and states
// no policy of its own. Before W10 each carried its own literals, so
// `SensorDataQoS` and `ServicesQoS` restated what `rclcpp::QoS::sensor_data()` and
// `rclcpp::QoS::services()` already said, 400 lines up in the same header — the
// shape upstream itself avoids: rclcpp's `SensorDataQoS` is
// `QoSInitialization::from_rmw(rmw_qos_profile_sensor_data)`, a REFERENCE to the
// rmw constant, never a re-transcription of it (`rclcpp/qos.hpp:391-399`).
//
// The reason a name-only class is still worth having is unchanged: two of these
// shipped WRONG, which is why the values are pinned by a test rather than by
// review.
//
//   * `ParametersQoS()` returned `QoS(10)` where `rmw_qos_profile_parameters`
//     is KEEP_LAST/**1000** — a hundredfold history difference under a name
//     that claims to be the ROS 2 profile, costing samples under load with
//     nothing to read.
//   * `SystemDefaultsQoS()` returned `QoS(10)`, which is
//     `rmw_qos_profile_default` — a DIFFERENT upstream profile. It is now
//     REFUSE-LOUD; see the class below for why no value can be right.
//
// The upstream sources, and the three fields folded into `QoS()` rather than
// spelled per row, are documented on `qos_table` itself — one place, because
// that is the whole point of this work item.
//
// These are CLASSES, as upstream's are, so `rclcpp::SensorDataQoS{}` — the
// brace form — compiles alongside `rclcpp::SensorDataQoS()`. They are
// `constexpr`, so the table-driven check lives in `static_assert`s
// (`tests/compile/ros2_api_adoption_stage2.cpp`) rather than in a runtime test
// no embedded lane runs.
 
class SensorDataQoS : public QoS {
  public:
    constexpr SensorDataQoS() : QoS(::rclcpp::detail::qos_table::sensor_data()) {}
};
 
class ServicesQoS : public QoS {
  public:
    constexpr ServicesQoS() : QoS(::rclcpp::detail::qos_table::services_default()) {}
};
 
class ParametersQoS : public QoS {
  public:
    constexpr ParametersQoS() : QoS(::rclcpp::detail::qos_table::parameters()) {}
};
 
class ParameterEventsQoS : public QoS {
  public:
    constexpr ParameterEventsQoS() : QoS(::rclcpp::detail::qos_table::parameter_events()) {}
};
 
class RosoutQoS : public QoS {
  public:
    constexpr RosoutQoS() : QoS(::rclcpp::detail::qos_table::rosout()) {}
};
 
class ClockQoS : public QoS {
  public:
    constexpr ClockQoS() : QoS(::rclcpp::detail::qos_table::clock()) {}
};
 
class SystemDefaultsQoS : public QoS {
  public:
    template <typename T = void> SystemDefaultsQoS() {
        static_assert(detail::refuse<T>::value, NROS_RCLCPP_REFUSE_SYSTEM_DEFAULTS_QOS);
    }
};
 
constexpr QoS KeepLast(::size_t depth) {
    return QoS(depth);
}
 
constexpr QoS KeepAll() {
    return QoS(::rclcpp::QoS().keep_all());
}
 
} // namespace rclcpp
 
#endif // NROS_RCLCPP_QOS_HPP