result.h

 
 
#ifndef HERMES_HERMES_COMMON_RESULT_H
#define HERMES_HERMES_COMMON_RESULT_H
 
#include <hermes/common/defs.h>
 
enum class HeResult {
  SUCCESS = 0,           
  ERROR = 1,             
  BAD_ALLOCATION = 2,    
  OUT_OF_BOUNDS = 3,     
  INVALID_INPUT = 4,     
  BAD_OPERATION = 5,     
  NOT_IMPLEMENTED = 6,   
};
 
namespace hermes {
 
template<class T>
struct UnexpectedResultType {
  T value{};
};
 
// *********************************************************************************************************************
//                                                                                                              Result
// *********************************************************************************************************************
template<class T, class E = HeResult>
class Result {
public:
  // *******************************************************************************************************************
  //                                                                                                 STATIC FUNCTIONS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE static Result<T, E> error(E e) {
    return Result<T, E>(UnexpectedResultType<E>{e});
  }
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE explicit Result(const UnexpectedResultType<E> &err = {}) : ok_(false) {
    new(reinterpret_cast<E *>(&err_)) E(err.value);
  }
  HERMES_DEVICE_CALLABLE explicit Result(const T &v) : ok_(true) {
    new(reinterpret_cast<T *>(&value_)) T(v);
  }
  HERMES_DEVICE_CALLABLE explicit Result(T &&v) : ok_(true) {
    new(reinterpret_cast<T *>(&value_)) T(std::move(v));
  }
  //                                                                                                       assignment
  HERMES_DEVICE_CALLABLE Result(const Result &other) {
    *this = other;
  }
  HERMES_DEVICE_CALLABLE Result(Result &&other) noexcept {
    *this = std::move(other);
  }
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE explicit operator bool() const noexcept { return ok_; }
  //                                                                                                       assignment
  HERMES_DEVICE_CALLABLE Result &operator=(const Result &other) {
    reset();
    ok_ = other.ok_;
    if (other.ok_)
      new(reinterpret_cast<T *>(&value_)) T(other.value());
    else
      new(reinterpret_cast<E *>(&err_)) E(other.status());
    return *this;
  }
  HERMES_DEVICE_CALLABLE Result &operator=(Result &&other) noexcept {
    reset();
    ok_ = other.ok_;
    if (other.ok_)
      new(reinterpret_cast<T *>(&value_)) T(std::move(other.value()));
    else
      new(reinterpret_cast<E *>(&err_)) E(std::move(other.status()));
    return *this;
  }
  HERMES_DEVICE_CALLABLE Result &operator=(const T &v) {
    reset();
    ok_ = true;
    new(reinterpret_cast<T *>(&value_)) T(v);
    return *this;
  }
  HERMES_DEVICE_CALLABLE Result &operator=(T &&v) {
    reset();
    ok_ = true;
    new(reinterpret_cast<T *>(&value_)) T(std::move(v));
    return *this;
  }
  //                                                                                                           access
  HERMES_DEVICE_CALLABLE T *operator->() { return &value(); }
  HERMES_DEVICE_CALLABLE const T *operator->() const { return &value(); }
  HERMES_DEVICE_CALLABLE T &operator*() { return value(); }
  HERMES_DEVICE_CALLABLE const T &operator*() const { return value(); }
  // *******************************************************************************************************************
  //                                                                                                          METHODS
  // *******************************************************************************************************************
  [[nodiscard]] HERMES_DEVICE_CALLABLE bool good() const { return ok_; }
  [[nodiscard]] HERMES_DEVICE_CALLABLE E status() const { return err_; }
  HERMES_DEVICE_CALLABLE void reset() {
    if (good()) {
      value().~T();
      ok_ = false;
    }
  }
  //                                                                                                           access
  HERMES_DEVICE_CALLABLE T valueOr(const T &v) const { return good() ? value() : v; }
  HERMES_DEVICE_CALLABLE T &value() {
    return *reinterpret_cast<T *>(&value_);
  }
  HERMES_DEVICE_CALLABLE const T &value() const {
    return *reinterpret_cast<const T *>(&value_);
  }
  // *******************************************************************************************************************
  //                                                                                                    PUBLIC FIELDS
  // *******************************************************************************************************************
private:
  union {
    E err_{};
    typename std::aligned_storage<sizeof(T), alignof(T)>::type value_;
  };
  bool ok_{false};
};
 
}
 
#endif //HERMES_HERMES_COMMON_RESULT_H