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,
    NROS_CPP_QOS_RELIABILITY_BEST_AVAILABLE = 4,
};
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,
    NROS_CPP_QOS_DURABILITY_BEST_AVAILABLE = 4,
};
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,
    NROS_CPP_QOS_LIVELINESS_BEST_AVAILABLE = 5,
};
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
 
// issue 2054 — upstream's rmw profile struct, under its upstream TAG.
// Declared here, incomplete, so `QoS` below can name it in three member
// declarations; it is DEFINED at the bottom of this file, after `QoS` is
// complete, because its conversion to `QoS` needs the whole class. The tag is
// upstream's `rmw_qos_profile_s`, not `rmw_qos_profile_t`, which is the RMW
// ABI's own struct in `<nros/rmw_entity.h>` — a different type with ABI field
// widths, which this declaration does not touch.
struct rmw_qos_profile_s;
 
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,
    BestAvailable = 4,
};

enum class DurabilityPolicy : int {
    Volatile = 0,
    TransientLocal = 1,
    SystemDefault = 2,
    Unknown = 3,
    BestAvailable = 4,
};

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,
    BestAvailable = 5,
};
 
class QoS;
struct QoSInitialization;
 
namespace detail {

constexpr uint32_t qos_window_ms(const Duration& d) {
    return d.nanoseconds() <= 0 ? 0u
           : d.nanoseconds() == INT64_MAX - 1
               ? UINT32_MAX - 1u
               : (d.nanoseconds() >= static_cast<int64_t>(UINT32_MAX - 1u) * 1000000 - 999999
                      ? UINT32_MAX
                      : static_cast<uint32_t>((d.nanoseconds() + 999999) / 1000000));
}

constexpr Duration qos_best_available_duration() {
    return Duration::from_nanoseconds(INT64_MAX - 1);
}

constexpr Duration qos_window_duration(uint32_t ms) {
    return ms == UINT32_MAX - 1u ? qos_best_available_duration()
                                 : 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); }

    explicit constexpr QoS(const QoSInitialization& init);
    constexpr QoS(const QoSInitialization& init, const ::rmw_qos_profile_s& profile);
 
    // -- 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& reliability_best_available() {
        reliability_ = ReliabilityPolicy::BestAvailable;
        return *this;
    }

    constexpr QoS& durability_best_available() {
        durability_ = DurabilityPolicy::BestAvailable;
        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; }

    constexpr ::rmw_qos_profile_s get_rmw_qos_profile() const;
 
  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); }

    static constexpr QoS best_available() {
        return QoS()
            .reliability_best_available()
            .durability_best_available()
            .keep_last(10)
            .liveliness(::rclcpp::LivelinessPolicy::BestAvailable)
            .deadline(::rclcpp::detail::qos_best_available_duration())
            .liveliness_lease_duration(::rclcpp::detail::qos_best_available_duration());
    }
};

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*);
    // issue 2054 — an `rmw_qos_profile_t` is a profile argument too, as
    // `create_service<S>(name, rmw_qos_profile_services_default)` passes it.
    // Incomplete here, which a pointer probe does not mind.
    static yes_t& probe(const ::rmw_qos_profile_s*);
    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 BestAvailableQoS : public QoS {
  public:
    constexpr BestAvailableQoS() : QoS(::rclcpp::detail::qos_table::best_available()) {}
};

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
 
// phase-488, issue 2054 — upstream's `rmw_qos_profile_t`, its policy enums and
// its `rmw_qos_profile_*` constants, as ported code spells them:
//
//     create_service<S>(name, cb, rmw_qos_profile_services_default, group);
//     rmw_qos_profile_t profile = rmw_qos_profile_default;
//     profile.depth = 1;
//     rclcpp::QoS qos(rclcpp::QoSInitialization::from_rmw(profile), profile);
//
// Field names, field types and enumerator values are upstream's
// (`rmw/types.h` and `rmw/time.h`, ROS 2 Humble; the BEST_AVAILABLE values are
// Iron's, and Humble code never names them). A profile converts IMPLICITLY to
// `rclcpp::QoS`, which is what every verb here takes, so Humble's
// `create_service(..., const rmw_qos_profile_t&, ...)` call sites compile
// unchanged; `QoS::get_rmw_qos_profile()` goes back.
//
// On every target, as the rest of this header is: RFC-0096 D1 is one API on
// every platform, and `rclcpp::QoSInitialization` is a public type. Nothing
// here needs the STL.
//
// The RMW ABI's `<nros/rmw_entity.h>` also defines a struct named
// `rmw_qos_profile_t` — the backend vtable's, with ABI field widths
// (`uint16_t depth`, `uint32_t deadline_ms`). That header is for a backend's
// implementation, never for a node, so a translation unit that includes both
// is a backend that also includes rclcpp; it is refused below with the reason
// rather than left to a redefinition error naming two files.
//
// `rmw_qos_profile_system_default` is still absent: every field of it is a
// sentinel, which a `QoS` request may not carry (see `qos_table`), and the two
// reference RMWs resolve it differently (issue 0829).
#if defined(NROS_RMW_ENTITY_H)
#error                                                                                             \
    "<rclcpp/qos.hpp> defines upstream's rmw_qos_profile_t, and <nros/rmw_entity.h> defines the RMW ABI's struct under the same name. A node includes rclcpp only; a backend includes the ABI header only (issue 2054)."
#endif
 
#include <stddef.h>

typedef struct rmw_time_s {
    uint64_t sec;
    uint64_t nsec;
} rmw_time_t;
 
#define RMW_DURATION_INFINITE                                                                      \
    { 9223372036LL, 854775807LL }
#define RMW_DURATION_UNSPECIFIED                                                                   \
    { 0LL, 0LL }
#define RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT 0
#define RMW_QOS_DEADLINE_DEFAULT RMW_DURATION_UNSPECIFIED
#define RMW_QOS_DEADLINE_BEST_AVAILABLE                                                            \
    { 9223372036LL, 854775806LL }
#define RMW_QOS_LIFESPAN_DEFAULT RMW_DURATION_UNSPECIFIED
#define RMW_QOS_LIVELINESS_LEASE_DURATION_DEFAULT RMW_DURATION_UNSPECIFIED
#define RMW_QOS_LIVELINESS_LEASE_DURATION_BEST_AVAILABLE                                           \
    { 9223372036LL, 854775806LL }
 
typedef enum rmw_qos_reliability_policy_e {
    RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT = 0,
    RMW_QOS_POLICY_RELIABILITY_RELIABLE = 1,
    RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT = 2,
    RMW_QOS_POLICY_RELIABILITY_UNKNOWN = 3,
    RMW_QOS_POLICY_RELIABILITY_BEST_AVAILABLE = 4,
} rmw_qos_reliability_policy_t;
 
typedef enum rmw_qos_history_policy_e {
    RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT = 0,
    RMW_QOS_POLICY_HISTORY_KEEP_LAST = 1,
    RMW_QOS_POLICY_HISTORY_KEEP_ALL = 2,
    RMW_QOS_POLICY_HISTORY_UNKNOWN = 3,
} rmw_qos_history_policy_t;
 
typedef enum rmw_qos_durability_policy_e {
    RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT = 0,
    RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL = 1,
    RMW_QOS_POLICY_DURABILITY_VOLATILE = 2,
    RMW_QOS_POLICY_DURABILITY_UNKNOWN = 3,
    RMW_QOS_POLICY_DURABILITY_BEST_AVAILABLE = 4,
} rmw_qos_durability_policy_t;
 
typedef enum rmw_qos_liveliness_policy_e {
    RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT = 0,
    RMW_QOS_POLICY_LIVELINESS_AUTOMATIC = 1,
    RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE = 2,
    RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC = 3,
    RMW_QOS_POLICY_LIVELINESS_UNKNOWN = 4,
    RMW_QOS_POLICY_LIVELINESS_BEST_AVAILABLE = 5,
} rmw_qos_liveliness_policy_t;
 
namespace rclcpp {
namespace detail {

constexpr rmw_time_t qos_window_to_rmw(uint32_t ms) {
    return ms == 0u                ? rmw_time_t{0u, 0u}
           : ms == UINT32_MAX      ? rmw_time_t{9223372036u, 854775807u}
           : ms == UINT32_MAX - 1u ? rmw_time_t{9223372036u, 854775806u}
                                   : rmw_time_t{ms / 1000u, (ms % 1000u) * 1000000u};
}

constexpr uint32_t qos_window_from_rmw(const rmw_time_t& t) {
    return (t.sec == 0u && t.nsec == 0u)                    ? 0u
           : (t.sec == 9223372036u && t.nsec == 854775807u) ? UINT32_MAX
           : (t.sec == 9223372036u && t.nsec == 854775806u)
               ? UINT32_MAX - 1u
               : (t.sec > 9000000000u ? UINT32_MAX
                                      : qos_window_ms(Duration::from_nanoseconds(
                                            static_cast<int64_t>(t.sec) * 1000000000 +
                                            static_cast<int64_t>(t.nsec))));
}
 
// Each policy as a switch, because the two vocabularies number them
// differently (`rclcpp::ReliabilityPolicy::Reliable` is 0, upstream's
// `RMW_QOS_POLICY_RELIABILITY_RELIABLE` is 1), so no cast could be right.
constexpr rmw_qos_reliability_policy_t qos_reliability_to_rmw(ReliabilityPolicy p) {
    return p == ReliabilityPolicy::Reliable        ? RMW_QOS_POLICY_RELIABILITY_RELIABLE
           : p == ReliabilityPolicy::BestEffort    ? RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT
           : p == ReliabilityPolicy::Unknown       ? RMW_QOS_POLICY_RELIABILITY_UNKNOWN
           : p == ReliabilityPolicy::BestAvailable ? RMW_QOS_POLICY_RELIABILITY_BEST_AVAILABLE
                                                   : RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT;
}
constexpr ReliabilityPolicy qos_reliability_from_rmw(rmw_qos_reliability_policy_t p) {
    return p == RMW_QOS_POLICY_RELIABILITY_RELIABLE         ? ReliabilityPolicy::Reliable
           : p == RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT    ? ReliabilityPolicy::BestEffort
           : p == RMW_QOS_POLICY_RELIABILITY_UNKNOWN        ? ReliabilityPolicy::Unknown
           : p == RMW_QOS_POLICY_RELIABILITY_BEST_AVAILABLE ? ReliabilityPolicy::BestAvailable
                                                            : ReliabilityPolicy::SystemDefault;
}
constexpr rmw_qos_history_policy_t qos_history_to_rmw(HistoryPolicy p) {
    return p == HistoryPolicy::KeepLast  ? RMW_QOS_POLICY_HISTORY_KEEP_LAST
           : p == HistoryPolicy::KeepAll ? RMW_QOS_POLICY_HISTORY_KEEP_ALL
           : p == HistoryPolicy::Unknown ? RMW_QOS_POLICY_HISTORY_UNKNOWN
                                         : RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT;
}
constexpr HistoryPolicy qos_history_from_rmw(rmw_qos_history_policy_t p) {
    return p == RMW_QOS_POLICY_HISTORY_KEEP_LAST  ? HistoryPolicy::KeepLast
           : p == RMW_QOS_POLICY_HISTORY_KEEP_ALL ? HistoryPolicy::KeepAll
           : p == RMW_QOS_POLICY_HISTORY_UNKNOWN  ? HistoryPolicy::Unknown
                                                  : HistoryPolicy::SystemDefault;
}
constexpr rmw_qos_durability_policy_t qos_durability_to_rmw(DurabilityPolicy p) {
    return p == DurabilityPolicy::Volatile         ? RMW_QOS_POLICY_DURABILITY_VOLATILE
           : p == DurabilityPolicy::TransientLocal ? RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL
           : p == DurabilityPolicy::Unknown        ? RMW_QOS_POLICY_DURABILITY_UNKNOWN
           : p == DurabilityPolicy::BestAvailable  ? RMW_QOS_POLICY_DURABILITY_BEST_AVAILABLE
                                                   : RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT;
}
constexpr DurabilityPolicy qos_durability_from_rmw(rmw_qos_durability_policy_t p) {
    return p == RMW_QOS_POLICY_DURABILITY_VOLATILE          ? DurabilityPolicy::Volatile
           : p == RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL ? DurabilityPolicy::TransientLocal
           : p == RMW_QOS_POLICY_DURABILITY_UNKNOWN         ? DurabilityPolicy::Unknown
           : p == RMW_QOS_POLICY_DURABILITY_BEST_AVAILABLE  ? DurabilityPolicy::BestAvailable
                                                            : DurabilityPolicy::SystemDefault;
}
constexpr rmw_qos_liveliness_policy_t qos_liveliness_to_rmw(LivelinessPolicy p) {
    return p == LivelinessPolicy::Automatic       ? RMW_QOS_POLICY_LIVELINESS_AUTOMATIC
           : p == LivelinessPolicy::ManualByTopic ? RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC
           : p == LivelinessPolicy::ManualByNode  ? RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE
           : p == LivelinessPolicy::Unknown       ? RMW_QOS_POLICY_LIVELINESS_UNKNOWN
           : p == LivelinessPolicy::BestAvailable ? RMW_QOS_POLICY_LIVELINESS_BEST_AVAILABLE
                                                  : RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT;
}
constexpr LivelinessPolicy qos_liveliness_from_rmw(rmw_qos_liveliness_policy_t p) {
    return p == RMW_QOS_POLICY_LIVELINESS_AUTOMATIC         ? LivelinessPolicy::Automatic
           : p == RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC ? LivelinessPolicy::ManualByTopic
           : p == RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE  ? LivelinessPolicy::ManualByNode
           : p == RMW_QOS_POLICY_LIVELINESS_UNKNOWN         ? LivelinessPolicy::Unknown
           : p == RMW_QOS_POLICY_LIVELINESS_BEST_AVAILABLE  ? LivelinessPolicy::BestAvailable
                                                            : LivelinessPolicy::SystemDefault;
}
 
} // namespace detail
} // namespace rclcpp

typedef struct rmw_qos_profile_s {
    rmw_qos_history_policy_t history;
    size_t depth;
    rmw_qos_reliability_policy_t reliability;
    rmw_qos_durability_policy_t durability;
    rmw_time_t deadline;
    rmw_time_t lifespan;
    rmw_qos_liveliness_policy_t liveliness;
    rmw_time_t liveliness_lease_duration;
    bool avoid_ros_namespace_conventions;
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    constexpr operator ::rclcpp::QoS() const {
        nros_cpp_qos_t f{};
        f.reliability = static_cast<nros_cpp_qos_reliability_t>(
            ::rclcpp::detail::qos_reliability_from_rmw(reliability));
        f.durability = static_cast<nros_cpp_qos_durability_t>(
            ::rclcpp::detail::qos_durability_from_rmw(durability));
        f.history =
            static_cast<nros_cpp_qos_history_t>(::rclcpp::detail::qos_history_from_rmw(history));
        f.liveliness_kind = static_cast<nros_cpp_qos_liveliness_t>(
            ::rclcpp::detail::qos_liveliness_from_rmw(liveliness));
        f.depth = static_cast<int>(depth);
        f.deadline_ms = ::rclcpp::detail::qos_window_from_rmw(deadline);
        f.lifespan_ms = ::rclcpp::detail::qos_window_from_rmw(lifespan);
        f.liveliness_lease_ms = ::rclcpp::detail::qos_window_from_rmw(liveliness_lease_duration);
        f.avoid_ros_namespace_conventions = avoid_ros_namespace_conventions ? 1 : 0;
        return ::rclcpp::detail::qos_from_ffi(f);
    }
} rmw_qos_profile_t;
 
namespace rclcpp {
namespace detail {

constexpr rmw_qos_profile_t qos_to_rmw(const QoS& q) {
    return rmw_qos_profile_t{qos_history_to_rmw(q.history()),
                             static_cast<size_t>(q.depth() < 0 ? 0 : q.depth()),
                             qos_reliability_to_rmw(q.reliability()),
                             qos_durability_to_rmw(q.durability()),
                             qos_window_to_rmw(qos_to_ffi(q).deadline_ms),
                             qos_window_to_rmw(qos_to_ffi(q).lifespan_ms),
                             qos_liveliness_to_rmw(q.liveliness()),
                             qos_window_to_rmw(qos_to_ffi(q).liveliness_lease_ms),
                             q.avoid_ros_namespace_conventions()};
}
 
} // namespace detail

struct QoSInitialization {
    rmw_qos_history_policy_t history_policy;
    size_t depth;
 
    constexpr QoSInitialization(rmw_qos_history_policy_t history_policy_arg, size_t depth_arg)
        : history_policy(history_policy_arg), depth(depth_arg) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    constexpr QoSInitialization(const QoS& qos)
        : history_policy(detail::qos_history_to_rmw(qos.history())),
          depth(static_cast<size_t>(qos.depth() < 0 ? 0 : qos.depth())) {}
 
    static constexpr QoSInitialization from_rmw(const rmw_qos_profile_t& profile) {
        return QoSInitialization(profile.history, profile.depth);
    }
};
 
constexpr QoS::QoS(const QoSInitialization& init, const ::rmw_qos_profile_s& profile)
    : QoS(static_cast<QoS>(profile)) {
    history_ = detail::qos_history_from_rmw(init.history_policy);
    depth_ = static_cast<int>(init.depth);
}
 
constexpr ::rmw_qos_profile_s QoS::get_rmw_qos_profile() const {
    return detail::qos_to_rmw(*this);
}
 
} // namespace rclcpp

static constexpr rmw_qos_profile_t rmw_qos_profile_default =
    ::rclcpp::detail::qos_to_rmw(::rclcpp::detail::qos_table::default_profile());
static constexpr rmw_qos_profile_t rmw_qos_profile_sensor_data =
    ::rclcpp::detail::qos_to_rmw(::rclcpp::detail::qos_table::sensor_data());
static constexpr rmw_qos_profile_t rmw_qos_profile_services_default =
    ::rclcpp::detail::qos_to_rmw(::rclcpp::detail::qos_table::services_default());
static constexpr rmw_qos_profile_t rmw_qos_profile_parameters =
    ::rclcpp::detail::qos_to_rmw(::rclcpp::detail::qos_table::parameters());
static constexpr rmw_qos_profile_t rmw_qos_profile_parameter_events =
    ::rclcpp::detail::qos_to_rmw(::rclcpp::detail::qos_table::parameter_events());
 
namespace rclcpp {
// Defined after the constants because it starts from one of them.
constexpr QoS::QoS(const QoSInitialization& init) : QoS(init, ::rmw_qos_profile_default) {}
} // namespace rclcpp
 
#endif // NROS_RCLCPP_QOS_HPP