optional.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <tenno/algorithm.hpp>
#include <type_traits> // std::is_constant_evaluated
 
namespace tenno
{
 
template <typename T> class optional
{
public:
  using value_type = T;
 
  constexpr optional() noexcept : _has_value(false)
  {
#if __cplusplus >= 202002L // C++20
    if (std::is_constant_evaluated())
    {
#endif
      _value = T();
#if __cplusplus >= 202002L // C++20
    }
#endif
  }
 
  constexpr optional(T value) noexcept : _has_value(true), _value(value)
  {
  }
 
  optional operator=(T &value) noexcept
  {
    this = optional(value);
  }
 
  constexpr T operator->() const noexcept
  {
    return this->_value;
  }
 
  constexpr T operator*() const noexcept
  {
    return this->_value;
  }
 
  constexpr bool has_value() const noexcept
  {
    return this->_has_value;
  }
 
  constexpr T value() const noexcept
  {
    return this->_value;
  }
 
  constexpr T value_or(const T &other) const noexcept
  {
    if (this->_has_value)
      return this->_value;
    return other;
  }
 
  void swap(optional &other) noexcept
  {
    if (this->_has_value && other.has_value())
      tenno::swap(*this, other);
  }
 
  void reset() noexcept
  {
    if (this->_has_value)
      this->_value.~T();
    *this = optional();
  }
 
  template <class... Args> T &emplace(Args &&...args)
  {
    *this = optional(T(args...));
    return this->_value;
  }
 
private:
  bool _has_value;
  union
  {
    T _value;
  };
};
 
} // namespace tenno