optional.hpp

Go to the documentation of this file.

 
#ifndef TABLEAU_HYPER_OPTIONAL_HPP
#define TABLEAU_HYPER_OPTIONAL_HPP
 
#if !defined(__cplusplus) || (__cplusplus < 201703L) /* Use own optional if C++ is older than C++17 */
#define hyper_use_own_optional
#endif
 
#ifdef hyper_use_own_optional
#include <exception>
#include <type_traits>
#include <utility>
#else
#include <optional>
#endif
 
#ifdef hyper_use_own_optional
// Our optional surrogate does not support `constexpr`
#define CONSTEXPR_OPTIONAL const
#else
#define CONSTEXPR_OPTIONAL constexpr
#endif
 
namespace hyperapi {
#ifndef hyper_use_own_optional /* C++17 or greater */
template <typename T>
using optional = std::optional<T>;
using bad_optional_access = std::bad_optional_access;
#else
class bad_optional_access : public std::exception {
   using std::exception::exception;
};
 
template <typename T>
class optional {
   private:
   alignas(T) char data[sizeof(T)];
 
   bool exists = false;
 
   public:
   using value_type = T;
 
   optional() noexcept = default;
 
   optional(const optional& other);
 
   optional(optional&& other);
 
   template <
      typename U = value_type,
      typename = typename std::enable_if<!std::is_same<typename std::decay<U>::type, optional<T>>::value>::type>
   optional(U&& value);
 
   optional& operator=(const optional& other);
 
   optional& operator=(optional&& other);
 
   template <typename Other>
   bool operator==(const optional<Other>& other) const noexcept {
      return (exists == other.exists) && ((!exists) || (**this == *other));
   }
   template <typename Other>
   bool operator!=(const optional<Other>& other) const noexcept { return !(*this == other); }
 
   ~optional() { reset(); }
 
   bool has_value() const noexcept { return exists; }
   explicit operator bool() const noexcept { return exists; }
 
   T& value() & {
      if (!*this) {
         throw bad_optional_access{};
      }
      return **this;
   }
   const T& value() const& {
      if (!*this) {
         throw bad_optional_access{};
      }
      return **this;
   }
   T&& value() && {
      if (!*this) {
         throw bad_optional_access{};
      }
      return **this;
   }
   const T&& value() const&& {
      if (!*this) {
         throw bad_optional_access{};
      }
      return **this;
   }
 
   template <typename U>
   T value_or(U&& default_value) const& {
      return bool(*this) ? **this : static_cast<T>(std::forward<U>(default_value));
   }
 
   template <typename U>
   T value_or(U&& default_value) && {
      return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(default_value));
   }
 
   T* operator->() noexcept { return ptr(); }
   const T* operator->() const noexcept { return ptr(); }
 
   const T& operator*() const& { return *ptr(); }
   T& operator*() & { return *ptr(); }
   const T&& operator*() const&& { return *ptr(); }
   T&& operator*() && { return std::move(*ptr()); }
 
   void reset() noexcept;
   void swap(optional& other);
   template <typename... Args>
   void emplace(Args&&... args);
 
   private:
   template <typename... Args>
   void create(Args&&... args);
 
   T* ptr() noexcept { return exists ? reinterpret_cast<T*>(data) : nullptr; }
   const T* ptr() const noexcept { return exists ? reinterpret_cast<const T*>(data) : nullptr; }
};
 
#endif
}
#include <hyperapi/impl/optional.impl.hpp>
#endif