optional.hpp

#pragma once
 
#include <exception>
#include <new>
#include <utility>
 
#include "../namespace.hpp"
#include "utilities.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace Shims
{
 
class bad_optional_access : public std::exception
{
public:
  bad_optional_access() = default;
};
 
struct nullopt_t
{
};
 
static constexpr nullopt_t nullopt = {};
 
template <class T>
class optional final
{
  using Storage = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
 
  bool has_value_;
  Storage value_;
 
public:
  using value_type = T;
 
  optional() noexcept
    : has_value_(false)
  {
  }
 
  optional(nullopt_t) noexcept
    : has_value_(false)
  {
  }
 
  template <class... ARGS>
  optional(in_place_t, ARGS &&... args)
    : has_value_(true)
  {
    new(&value_) T(std::forward<ARGS>(args)...);
  }
 
  template <class U, typename std::enable_if<std::is_assignable<T&, U>::value, int>::type = 0>
  optional(U &&value)
    : has_value_(true)
  {
    new(&value_) T(std::forward<U>(value));
  }
 
  template <class U, typename std::enable_if<std::is_assignable<T&, U>::value, int>::type = 0>
  optional &operator=(U &&value)
  {
    if(this->has_value_)
    {
      reinterpret_cast<T &>(value_).operator=(std::forward<U>(value));
    }
    else
    {
      new(&value_) T(std::forward<U>(value));
      has_value_ = true;
    }
 
    return *this;
  }
 
  template <typename std::enable_if<std::is_copy_constructible<T>::value, int>::type = 0>
  optional(const optional &rhs)
    : has_value_(rhs.has_value_)
  {
    if(rhs.has_value_)
    {
      new(&value_) T(*rhs);
    }
  }
 
  template <typename std::enable_if<std::is_copy_assignable<T>::value, int>::type = 0>
  optional &operator=(const optional &rhs)
  {
    if(this != &rhs)
    {
      if(has_value_)
      {
        if(rhs.has_value_)
          reinterpret_cast<T &>(value_).operator=(*rhs);
        else
          this->reset();
      }
      else if(rhs.has_value_)
      {
        new(&value_) T(*rhs);
        has_value_ = true;
      }
    }
 
    return *this;
  }
 
  template <typename std::enable_if<std::is_move_constructible<T>::value, int>::type = 0>
  optional(optional &&rhs)
    : has_value_(rhs.has_value_)
  {
    if(rhs.has_value_)
    {
      new(&value_) T(std::move(*rhs));
      rhs.reset();
    }
  }
 
  template <typename std::enable_if<std::is_move_assignable<T>::value, int>::type = 0>
  optional &operator=(optional &&rhs)
  {
    if(this != &rhs)
    {
      if(has_value_)
      {
        if(rhs.has_value_)
        {
          reinterpret_cast<T &>(value_).operator=(std::move(*rhs));
          rhs.reset();
        }
        else
        {
          this->reset();
        }
      }
      else if(rhs.has_value_)
      {
        new(&value_) T(std::move(*rhs));
        has_value_ = true;
        rhs.reset();
      }
    }
 
    return *this;
  }
 
  ~optional()
  {
    this->reset();
  }
 
  const T *operator->() const noexcept
  {
    return &reinterpret_cast<const T &>(value_);
  }
 
  T *operator->() noexcept
  {
    return &reinterpret_cast<T &>(value_);
  }
 
  const T &operator*() const noexcept
  {
    return reinterpret_cast<const T &>(value_);
  }
 
  T &operator*() noexcept
  {
    return reinterpret_cast<T &>(value_);
  }
 
  explicit operator bool() const noexcept
  {
    return has_value_;
  }
 
  template <class... ARGS>
  T &emplace(ARGS &&... args)
  {
    this->reset();
    auto pValue = new(&value_) T(std::forward<ARGS>(args)...);
    has_value_ = true;
    return *pValue;
  }
 
  bool has_value() const noexcept
  {
    return has_value_;
  }
 
  void reset()
  {
    if(has_value_)
    {
      reinterpret_cast<T &>(value_).~T();
      has_value_ = false;
    }
  }
 
  void swap(optional &other)
  {
    auto old = std::move(*this);
    *this = std::move(other);
    other = std::move(old);
  }
 
  const T &value() const
  {
    if(!has_value_)
      throw bad_optional_access{};
 
    return reinterpret_cast<const T &>(value_);
  }
 
  T &value()
  {
    if(!has_value_)
      throw bad_optional_access{};
 
    return reinterpret_cast<T &>(value_);
  }
 
  template <class U, typename std::enable_if<std::is_assignable<T&, U>::value, int>::type = 0>
  T value_or(U &&default_value) const
  {
    if(has_value_)
      return reinterpret_cast<const T &>(value_);
    else
      return default_value;
  }
};
 
template <class T>
optional<typename std::decay<T>::type> make_optional(T &&value)
{
  return optional<typename std::decay<T>::type>{std::forward<T>(value)};
}
 
template <class T, class... ARGS>
optional<T> make_optional(ARGS &&... args)
{
  return optional<T>{in_place, std::forward<ARGS>(args)...};
}
 
} // namespace Shims
 
CVB_END_INLINE_NS
 
} // namespace Cvb
 
namespace std
{
template <class T>
void swap(Cvb::Shims::optional<T> &lhs, Cvb::Shims::optional<T> &rhs)
{
  lhs.swap(rhs);
}
} // namespace std