result.hpp

Go to the documentation of this file.

// nros-cpp: Result type for error handling
// Freestanding C++ — no exceptions, no STL required

 
#ifndef NROS_RCLCPP_RESULT_HPP
#define NROS_RCLCPP_RESULT_HPP
 
#include <cstdint>
 
#include "rclcpp/detail/traits.hpp"
#if defined(NROS_CPP_STD) || (__STDC_HOSTED__ + 0) // hosted-family: hosted-console
#include <cstdio>
// <stdio.h> + unqualified `::fprintf` (issue 0942 / phase-472 W5): `<cstdio>` need not put
// the C names in `std` on a freestanding libstdc++, and `std::fprintf` then fails.
#include <stdio.h>
#endif

#ifndef NROS_NODISCARD
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(nodiscard) >= 201603L
#if defined(__clang__) && __cplusplus < 201703L
#define NROS_NODISCARD __attribute__((warn_unused_result))
#else
#define NROS_NODISCARD [[nodiscard]]
#endif
#endif
#endif
#endif
#ifndef NROS_NODISCARD
#define NROS_NODISCARD
#endif

#ifndef NROS_CPP_DEPRECATED_MSG
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(deprecated)
#define NROS_CPP_DEPRECATED_MSG(msg) [[deprecated(msg)]]
#endif
#endif
#endif
#ifndef NROS_CPP_DEPRECATED_MSG
#if defined(__GNUC__) || defined(__clang__)
#define NROS_CPP_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
#else
#define NROS_CPP_DEPRECATED_MSG(msg)
#endif
#endif
 
namespace rclcpp {

enum class ErrorCode : int32_t {
    Ok = 0,
    Error = -1,
    Timeout = -2,
    InvalidArgument = -3,
    NotFound = -4,
    AlreadyExists = -5,
    Full = -6,
    NotInitialized = -7,
    BadSequence = -8,
    ServiceFailed = -9,
    PublishFailed = -10,
    SubscriptionFailed = -11,
    NotAllowed = -12,
    Rejected = -13,
    TryAgain = -14,
    Reentrant = -15,
    Unsupported = -16,
    TransportError = -100,
};
 
// Issue #229 pin (self-consistency half): the values above ARE the shared
// numbering. The cross-space asserts against the real C constants live in
// parameter.hpp (vs NROS_RET_*) and node.hpp (vs NROS_CPP_RET_*), where
// those headers are visible.
static_assert(static_cast<int32_t>(ErrorCode::NotFound) == -4 &&
                  static_cast<int32_t>(ErrorCode::AlreadyExists) == -5 &&
                  static_cast<int32_t>(ErrorCode::Full) == -6 &&
                  static_cast<int32_t>(ErrorCode::NotInitialized) == -7 &&
                  static_cast<int32_t>(ErrorCode::TryAgain) == -14 &&
                  static_cast<int32_t>(ErrorCode::Reentrant) == -15 &&
                  static_cast<int32_t>(ErrorCode::Unsupported) == -16,
              "ErrorCode numbering must match rcl_ret_t (issue #229)");

template <typename T> class ResultOf;

template <> class NROS_NODISCARD ResultOf<void> {
  public:
    constexpr ResultOf() : code_(ErrorCode::Ok) {}
    constexpr ResultOf(ErrorCode code) : code_(code) {}
    constexpr ResultOf(int32_t raw) : code_(static_cast<ErrorCode>(raw)) {}

    bool ok() const { return code_ == ErrorCode::Ok; }

    explicit operator bool() const { return ok(); }

    ErrorCode code() const { return code_; }

    int32_t raw() const { return static_cast<int32_t>(code_); }

    static constexpr ResultOf success() { return ResultOf(ErrorCode::Ok); }
 
  private:
    ErrorCode code_;
};

using Result = ResultOf<void>;

#define RCLCPP_TRY(expr)                                                                           \
    do {                                                                                           \
        ::rclcpp::Result _nros_r = (expr);                                                         \
        if (!_nros_r.ok()) return _nros_r;                                                         \
    } while (0)

#ifndef RCLCPP_TRY_LOG
#if defined(NROS_CPP_STD) || (__STDC_HOSTED__ + 0) // hosted-family: hosted-console
#define RCLCPP_TRY_LOG(file, line, expr, ret)                                                      \
    ::fprintf(stderr, "[nros] %s:%d %s -> %d\n", (file), (line), (expr), (int)(ret))
#else
#define RCLCPP_TRY_LOG(file, line, expr, ret)                                                      \
    ((void)(file), (void)(line), (void)(expr), (void)(ret))
#endif
#endif
 
#define RCLCPP_TRY_RET(expr, retval)                                                               \
    do {                                                                                           \
        ::rclcpp::Result _nros_r = (expr);                                                         \
        if (!_nros_r.ok()) {                                                                       \
            RCLCPP_TRY_LOG(__FILE__, __LINE__, #expr, _nros_r.raw());                              \
            return (retval);                                                                       \
        }                                                                                          \
    } while (0)

#define RCLCPP_CHECK(expr)                                                                         \
    do {                                                                                           \
        ::rclcpp::Result _nros_r = (expr);                                                         \
        if (!_nros_r.ok()) {                                                                       \
            RCLCPP_TRY_LOG(__FILE__, __LINE__, #expr, _nros_r.raw());                              \
            return;                                                                                \
        }                                                                                          \
    } while (0)

template <typename T> class NROS_NODISCARD ResultOf {
  public:
    static ResultOf ok(T value) {
        ResultOf e;
        e.ok_ = true;
        e.value_ = ::rclcpp::tr::forward_rvalue(value);
        return e;
    }
    static ResultOf error(ErrorCode code) {
        ResultOf e;
        e.ok_ = false;
        e.error_ = code;
        return e;
    }
    static ResultOf error(const Result& r) { return error(r.code()); }
 
    bool ok() const { return ok_; }
    explicit operator bool() const { return ok_; }
 
    T& value() & { return value_; }
    const T& value() const& { return value_; }
    T&& value() && { return ::rclcpp::tr::forward_rvalue(value_); }
 
    ErrorCode error() const { return error_; }
    Result error_as_result() const { return Result(error_); }
 
  private:
    ResultOf() : ok_(false), error_(ErrorCode::Error), value_() {}
 
    bool ok_;
    ErrorCode error_;
    T value_;
};
 
} // namespace rclcpp
 
// ============================================================================
// rclcpp:: — the ROS 2 spelling (RFC-0089 stage 6, step A)
// ============================================================================
//
// Moved here from `nros/rclcpp_compat.hpp`, which no longer carries a surface
// of its own: 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, at which point a shim has nothing left to bridge.
 
// `rclcpp::Result` is NOT an upstream rclcpp name — it is a convenience the
// compat header carried, kept here because step A must not lose anything. It
// re-exported `nros::Result` until phase-483 W1 made it the type itself (the
// using-declaration below is now a no-op); RFC-0018 forbids exceptions, so
// there is no upstream error type to adopt in its place.
namespace rclcpp {
using ::rclcpp::Result;
} // namespace rclcpp
 
#if defined(NROS_CPP_STD) // hosted-family: ported-publish
namespace rclcpp {
namespace detail {
class StatementResult : public ::rclcpp::ResultOf<void> {
  public:
    constexpr StatementResult(::rclcpp::ResultOf<void> r) : ::rclcpp::ResultOf<void>(r) {}
};
} // namespace detail
} // namespace rclcpp
#endif
 
#endif // NROS_RCLCPP_RESULT_HPP