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_CPP_RESULT_HPP
#define NROS_CPP_RESULT_HPP
 
#include <cstdint>
#include <utility>
#if defined(NROS_CPP_STD) || (__STDC_HOSTED__ + 0)
#include <cstdio>
#endif
 
namespace nros {
 
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 nros_ret_t (issue #229)");
 
class Result {
  public:
    constexpr Result() : code_(ErrorCode::Ok) {}
    constexpr Result(ErrorCode code) : code_(code) {}
    constexpr Result(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 Result success() { return Result(ErrorCode::Ok); }
 
  private:
    ErrorCode code_;
};
 
#define NROS_TRY(expr)                                                                             \
    do {                                                                                           \
        ::nros::Result _nros_r = (expr);                                                           \
        if (!_nros_r.ok()) return _nros_r;                                                         \
    } while (0)
 
#ifndef NROS_TRY_LOG
#if defined(NROS_CPP_STD) || (__STDC_HOSTED__ + 0)
#define NROS_TRY_LOG(file, line, expr, ret)                                                        \
    ::std::fprintf(stderr, "[nros] %s:%d %s -> %d\n", (file), (line), (expr), (int)(ret))
#else
#define NROS_TRY_LOG(file, line, expr, ret) ((void)(file), (void)(line), (void)(expr), (void)(ret))
#endif
#endif
 
#define NROS_TRY_RET(expr, retval)                                                                 \
    do {                                                                                           \
        ::nros::Result _nros_r = (expr);                                                           \
        if (!_nros_r.ok()) {                                                                       \
            NROS_TRY_LOG(__FILE__, __LINE__, #expr, _nros_r.raw());                                \
            return (retval);                                                                       \
        }                                                                                          \
    } while (0)
 
#define NROS_CHECK(expr)                                                                           \
    do {                                                                                           \
        ::nros::Result _nros_r = (expr);                                                           \
        if (!_nros_r.ok()) {                                                                       \
            NROS_TRY_LOG(__FILE__, __LINE__, #expr, _nros_r.raw());                                \
            return;                                                                                \
        }                                                                                          \
    } while (0)
 
template <typename T> class Expected {
  public:
    static Expected ok(T value) {
        Expected e;
        e.ok_ = true;
        e.value_ = ::std::move(value);
        return e;
    }
    static Expected error(ErrorCode code) {
        Expected e;
        e.ok_ = false;
        e.error_ = code;
        return e;
    }
    static Expected 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 ::std::move(value_); }
 
    ErrorCode error() const { return error_; }
    Result error_as_result() const { return Result(error_); }
 
  private:
    Expected() : ok_(false), error_(ErrorCode::Error), value_() {}
 
    bool ok_;
    ErrorCode error_;
    T value_;
};
 
} // namespace nros
 
#endif // NROS_CPP_RESULT_HPP