optional.h

Go to the documentation of this file.

 
#ifndef HERMES_HERMES_COMMON_OPTIONAL_H
#define HERMES_HERMES_COMMON_OPTIONAL_H
 
#include <hermes/common/defs.h>
#include <iostream>
 
namespace hermes {
 
// *********************************************************************************************************************
//                                                                                                              Optional
// *********************************************************************************************************************
template<typename T>
class Optional {
public:
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  //                                                                                                              new
  HERMES_DEVICE_CALLABLE Optional() {}
  HERMES_DEVICE_CALLABLE explicit Optional(const T &v) : has_value_(true) {
    new(reinterpret_cast<T *>(&value_)) T(v);
  }
  HERMES_DEVICE_CALLABLE explicit Optional(T &&v) : has_value_(true) {
    new(reinterpret_cast<T *>(&value_)) T(std::move(v));
  }
  HERMES_DEVICE_CALLABLE ~Optional() { reset(); }
  //                                                                                                       assignment
  HERMES_DEVICE_CALLABLE Optional(const Optional &other) {
    *this = other;
  }
  HERMES_DEVICE_CALLABLE Optional(Optional &&other) noexcept {
    *this = std::move(other);
  }
  // *******************************************************************************************************************
  //                                                                                                        OPERATORS
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE explicit operator bool() const { return has_value_; }
  //                                                                                                       assignment
  HERMES_DEVICE_CALLABLE Optional &operator=(const Optional &other) {
    reset();
    if (other.has_value_) {
      has_value_ = true;
      new(reinterpret_cast<T *>(&value_)) T(other.value());
    }
    return *this;
  }
  HERMES_DEVICE_CALLABLE Optional &operator=(Optional &&other) noexcept {
    reset();
    if (other.has_value_) {
      has_value_ = true;
      new(reinterpret_cast<T *>(&value_)) T(std::move(other.value()));
    }
    return *this;
  }
  HERMES_DEVICE_CALLABLE Optional &operator=(const T &v) {
    reset();
    new(reinterpret_cast<T *>(&value_)) T(v);
    has_value_ = true;
    return *this;
  }
  HERMES_DEVICE_CALLABLE Optional &operator=(T &&v) {
    reset();
    new(reinterpret_cast<T *>(&value_)) T(std::move(v));
    has_value_ = true;
    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
  // *******************************************************************************************************************
  HERMES_DEVICE_CALLABLE void reset() {
    if (has_value_) {
      value().~T();
      has_value_ = false;
    }
  }
  [[nodiscard]] HERMES_DEVICE_CALLABLE bool hasValue() const { return has_value_; }
  //                                                                                                           access
  HERMES_DEVICE_CALLABLE T valueOr(const T &v) const { return has_value_ ? 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_);
  }
private:
  bool has_value_{false};
  typename std::aligned_storage<sizeof(T), alignof(T)>::type value_;
};
 
// *********************************************************************************************************************
//                                                                                                                 IO
// *********************************************************************************************************************
template<typename T>
inline std::ostream &operator<<(std::ostream &o, const Optional<T> &optional) {
  if (optional.hasValue())
    return o << "Optional<" << typeid(T).name() << "> = " << optional.hasValue();
  return o << "Optional<" << typeid(T).name() << "> = [no value]";
}
 
}
 
#endif //HERMES_HERMES_COMMON_OPTIONAL_H