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;
    };
    class bad_optional_access : public std::exception {…};

    struct nullopt_t
    {
    };
    struct nullopt_t {…};

    static constexpr nullopt_t nullopt = {};

    template <class T>
    class optional final  // NOLINT(cppcoreguidelines-special-member-functions) requires generated no default move to
                          // work correctly
    {
      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() noexcept {…}

      optional(nullopt_t) noexcept  // NOLINT
          : has_value_(false)
      {
      }
      optional(nullopt_t) noexcept  // NOLINT {…}

      template <class... ARGS>
      optional(in_place_t, ARGS &&...args)  // NOLINT
          : has_value_(true)
      {
        new (&value_) T(std::forward<ARGS>(args)...);
      }
      optional(in_place_t, ARGS &&...args)  // NOLINT {…}

      template <class U, typename std::enable_if<std::is_assignable<T &, U>::value, int>::type = 0>
      optional(U &&value)  // NOLINT
          : has_value_(true)
      {
        new (&value_) T(std::forward<U>(value));
      }
      optional(U &&value)  // NOLINT {…}

      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;
      }
      optional &operator=(U &&value) {…}

      template <typename std::enable_if<std::is_copy_constructible<T>::value, int>::type = 0>
      optional(const optional &rhs)  // NOLINT
          : has_value_(rhs.has_value_)
      {
        if (rhs.has_value_)
        {
          new (&value_) T(*rhs);
        }
      }
      optional(const optional &rhs)  // NOLINT {…}

      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;
      }
      optional &operator=(const optional &rhs) {…}

      template <typename std::enable_if<std::is_move_constructible<T>::value, int>::type = 0>
      optional(optional &&rhs)  // NOLINT
          : has_value_(rhs.has_value_)
      {
        if (rhs.has_value_)
        {
          new (&value_) T(std::move(*rhs));
          rhs.reset();
        }
      }
      optional(optional &&rhs)  // NOLINT {…}

      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 &operator=(optional &&rhs) {…}
 
      optional(const optional &other)            = default;
      optional &operator=(const optional &other) = default;
      ~optional()
      {
        this->reset();
      }

      const T *operator->() const noexcept
      {
        return &reinterpret_cast<const T &>(value_);
      }
      const T *operator->() const noexcept {…}

      T *operator->() noexcept
      {
        return &reinterpret_cast<T &>(value_);
      }
      T *operator->() noexcept {…}

      const T &operator*() const noexcept
      {
        return reinterpret_cast<const T &>(value_);
      }
      const T &operator*() const noexcept {…}

      T &operator*() noexcept
      {
        return reinterpret_cast<T &>(value_);
      }
      T &operator*() noexcept {…}

      explicit operator bool() const noexcept
      {
        return has_value_;
      }
      explicit operator bool() const noexcept {…}

      template <class... ARGS>
      T &emplace(ARGS &&...args)
      {
        this->reset();
        auto pValue = new (&value_) T(std::forward<ARGS>(args)...);  // NOLINT(cppcoreguidelines-owning-memory)
        has_value_  = true;
        return *pValue;
      }
      T &emplace(ARGS &&...args) {…}

      bool has_value() const noexcept
      {
        return has_value_;
      }
      bool has_value() const noexcept {…}

      void reset()
      {
        if (has_value_)
        {
          reinterpret_cast<T &>(value_).~T();
          has_value_ = false;
        }
      }
      void reset() {…}

      void swap(optional &other)
      {
        auto old = std::move(*this);
        *this    = std::move(other);
        other    = std::move(old);
      }
      void swap(optional &other) {…}

      const T &value() const
      {
        if (!has_value_)
          throw bad_optional_access{};
 
        return reinterpret_cast<const T &>(value_);
      }
      const T &value() const {…}

      T &value()
      {
        if (!has_value_)
          throw bad_optional_access{};
 
        return reinterpret_cast<T &>(value_);
      }
      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;
      }
      T value_or(U &&default_value) const {…}
    };
    class optional final  // NOLINT(cppcoreguidelines-special-member-functions) requires generated no default move to {…};

    template <class T>
    optional<typename std::decay<T>::type> make_optional(T &&value)
    {
      return optional<typename std::decay<T>::type>{std::forward<T>(value)};
    }
    optional<typename std::decay<T>::type> make_optional(T &&value) {…}

    template <class T, class... ARGS>
    optional<T> make_optional(ARGS &&...args)
    {
      return optional<T>{in_place, std::forward<ARGS>(args)...};
    }
    optional<T> make_optional(ARGS &&...args) {…}
 
  }  // namespace Shims
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb
 
namespace std  // NOLINT(cert-dcl58-cpp)
{
  template <class T>
  void swap(Cvb::Shims::optional<T> &lhs, Cvb::Shims::optional<T> &rhs)  // NOLINT(cert-dcl58-cpp)
  {
    lhs.swap(rhs);
  }
}  // namespace std