optional.h

Go to the documentation of this file.

 
 
/******************************************************************************
The MIT License(MIT)
 
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
 
Copyright(c) 2015 John Wellbelove
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
 
#ifndef ETL_OPTIONAL_INCLUDED
#define ETL_OPTIONAL_INCLUDED
 
#include "platform.h"
#include "alignment.h"
#include "memory.h"
#include "type_traits.h"
#include "exception.h"
#include "error_handler.h"
#include "utility.h"
#include "placement_new.h"
 
namespace etl
{
  //*****************************************************************************
  //*****************************************************************************
  class nullopt_t
  {
  public:
 
    // Convertible to any type of null non-member pointer.
    template<class T>
    operator T*() const
    {
      return 0;
    }
 
  private:
 
    // Can't take address of nullopt.
    void operator&() const ETL_DELETE;
  };
 
  //*****************************************************************************
  //*****************************************************************************
  const nullopt_t nullopt = {};
 
  //***************************************************************************
  //***************************************************************************
  class optional_exception : public exception
  {
  public:
 
    optional_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
      : exception(reason_, file_name_, line_number_)
    {
    }
  };
 
  //***************************************************************************
  //***************************************************************************
  class optional_invalid : public optional_exception
  {
  public:
 
    optional_invalid(string_type file_name_, numeric_type line_number_)
      : optional_exception("optional:invalid", file_name_, line_number_)
    {
    }
  };
 
  //*****************************************************************************
  //*****************************************************************************
  template <typename T, bool is_pod = etl::is_pod<T>::value>
  class optional;
 
  //*****************************************************************************
  //*****************************************************************************
  template <typename T>
  class optional<T, false>
  {
  public:
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR
    optional()
      : storage()
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR
    optional(etl::nullopt_t)
      : storage()
    {
    }
 
#include "etl/private/diagnostic_uninitialized_push.h"
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional(const optional& other)
    {
      if (other.has_value())
      {
        storage.construct(other.value());
      }
    }
#include "etl/private/diagnostic_pop.h"
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional(optional&& other)
    {
      if (other.has_value())
      {
        storage.construct(etl::move(other.value()));
      }
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional(const T& value_)
    {
      storage.construct(value_);
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional(T&& value_)
    {
      storage.construct(etl::move(value_));
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    ~optional()
    {
      storage.destroy();
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional& operator =(etl::nullopt_t)
    {
      if (has_value())
      {
        storage.destroy();
      }
 
      return *this;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional& operator =(const optional& other)
    {
      if (this != &other)
      {
        if (other.has_value())
        {
          storage.construct(other.value());
        }
        else
        {
          storage.destroy();
        }
      }
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional& operator =(optional&& other)
    {
      if (this != &other)
      {
        if (other.has_value())
        {
          storage.construct(etl::move(other.value()));
        }
        else
        {
          storage.destroy();
        }
      }
 
      return *this;
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional& operator =(const T& value_)
    {
      storage.construct(value_);
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    optional& operator =(T&& value_)
    {
      storage.construct(etl::move(value_));
 
      return *this;
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T* operator ->()
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return &storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const T* operator ->() const
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return &storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T& operator *() ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const T& operator *() const ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T&& operator *()&&
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const T&& operator *() const&&
    {
#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
#endif
 
    //***************************************************************************
    // Check whether optional contains value
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    bool has_value() const ETL_NOEXCEPT
    {
      return storage.valid;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    ETL_EXPLICIT operator bool() const
    {
      return has_value();
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T& value() ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const T& value() const ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
    {
      return has_value() ? value() : default_value;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    T&& value()&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const T&& value() const&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U>
    ETL_CONSTEXPR20_STL
    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
      value_or(U&& default_value) const&
    {
      return has_value() ? value() : etl::forward<T>(default_value);
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U>
    ETL_CONSTEXPR20_STL
    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
      value_or(U&& default_value) &&
    {
      return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    void swap(optional& other)
    {
      optional temp(*this);
      *this = other;
      other = temp;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    void reset()
    {
      storage.destroy();
    }
 
#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
    //*************************************************************************
    //*************************************************************************   
    template <typename ... TArgs>
    ETL_CONSTEXPR20_STL
    void emplace(TArgs&& ... args)
    {
      storage.construct(etl::forward<TArgs>(args)...);
    }
#else
    //*************************************************************************
    //*************************************************************************
    template <typename T1>
    T& emplace(const T1& value1)
    {
      if (has_value())
      {
        // Destroy the old one.
        storage.destroy();
      }
 
      T* p = ::new (&storage.u.value) T(value1);
      storage.valid = true;
 
      return *p;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2>
    T& emplace(const T1& value1, const T2& value2)
    {
      if (has_value())
      {
        // Destroy the old one.
        storage.destroy();
      }
 
      T* p = ::new (&storage.u.value) T(value1, value2);
      storage.valid = true;
 
      return *p;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2, typename T3>
    T& emplace(const T1& value1, const T2& value2, const T3& value3)
    {
      if (has_value())
      {
        // Destroy the old one.
        storage.destroy();
      }
 
      T* p = ::new (&storage.u.value) T(value1, value2, value3);
      storage.valid = true;
 
      return *p;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2, typename T3, typename T4>
    T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
    {
      if (has_value())
      {
        // Destroy the old one.
        storage.destroy();
      }
 
      T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
      storage.valid = true;
 
      return *p;
    }
#endif
 
  private:
 
    struct storage_type
    {
      //*******************************
      ETL_CONSTEXPR20_STL
      storage_type()
        : u()
        , valid(false)
      {
      }
 
      //*******************************
      ETL_CONSTEXPR20_STL
      ~storage_type()
      {
        destroy();
      }
 
      //*******************************
      ETL_CONSTEXPR20_STL
      void construct(const T& value_)
      {
        if (valid)
        {
          u.value = value_;
        }
        else
        {
          etl::construct_at(&u.value, value_);
          valid = true;
        }
      }
 
#if ETL_USING_CPP11
      //*******************************
      ETL_CONSTEXPR20_STL
      void construct(T&& value_)
      {
        if (valid)
        {
          u.value = etl::move(value_);
        }
        else
        {
          etl::construct_at(&u.value, etl::move(value_));
          valid = true;
        }
      }
 
      //*******************************
      template <typename... TArgs>
      ETL_CONSTEXPR20_STL
      void construct(TArgs&&... args)
      {
        destroy();
        etl::construct_at(&u.value, etl::forward<TArgs>(args)...);
        valid = true;
      }
#endif
 
      //*******************************
      ETL_CONSTEXPR20_STL
      void destroy()
      {
        if (valid)
        {
          etl::destroy_at(&u.value);
          valid = false;
        }
      }
 
      //*******************************
      union union_type
      {
        ETL_CONSTEXPR20_STL
        union_type()
          : dummy(0)
        {
        }
 
        ETL_CONSTEXPR20_STL
        ~union_type()
        {
        }
 
        char dummy;
        T    value;
      } u;
 
      bool valid;
    };
 
    storage_type storage;
  };
 
  //*****************************************************************************
  //*****************************************************************************
  template <typename T>
  class optional<T, true>
  {
  public:
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional()
      : valid(false)
      , storage()
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional(etl::nullopt_t)
      : valid(false)
      , storage()
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional(const optional& other)
      : valid(bool(other))
      , storage(other.storage)
    {
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional(optional&& other)
      : valid(bool(other))
      , storage(etl::move(other.storage))
    {
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional(const T& value_)
      : valid(true)
    {
      storage.u.value = value_;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional(T&& value_)
      : valid(true)
    {
      storage.u.value = etl::move(value_);
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional& operator =(etl::nullopt_t)
    {
      valid = false;
      return *this;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional& operator =(const optional& other)
    {
      if (this != &other)
      {
        storage.u = other.storage.u;
        valid   = other.valid;
      }
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional& operator =(optional&& other)
    {
      if (this != &other)
      {
        storage.u = etl::move(other.storage.u);
        valid   = other.valid;
      }
 
      return *this;
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional& operator =(const T& value_)
    {
      storage.u.value = value_;
      valid = true;
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 optional& operator =(T&& value_)
    {
      storage.u.value = etl::move(value_);
      valid = true;
 
      return *this;
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T* operator ->()
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return &storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 const T* operator ->() const
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return &storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T& operator *() ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 const T& operator *() const ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T&& operator *()&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 const T&& operator *() const&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 
    ETL_EXPLICIT operator bool() const
    {
      return valid;
    }
 
    //***************************************************************************
    // Check whether optional contains value
    //***************************************************************************
    ETL_CONSTEXPR14 bool has_value() const ETL_NOEXCEPT
    {
      return valid;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T& value() ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 const T& value() const ETL_LVALUE_REF_QUALIFIER
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return storage.u.value;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
    {
      return valid ? value() : default_value;
    }
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 T&& value()&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 const T&& value() const&&
    {
#if ETL_IS_DEBUG_BUILD
      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
#endif
 
      return etl::move(storage.u.value);
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U>
    ETL_CONSTEXPR20_STL
    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
      value_or(U&& default_value) const&
    {
      if (has_value())
      {
        return value();
      }
      else
      {
        return static_cast<T>(etl::forward<U>(default_value));
      }
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U>
    ETL_CONSTEXPR20_STL
    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
      value_or(U&& default_value) &&
    {
      if (has_value())
      {
        return etl::move(value());
      }
      else
      {
        return static_cast<T>(etl::forward<U>(default_value));
      }
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 void swap(optional& other)
    {
      optional temp(*this);
      *this = other;
      other = temp;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR14 void reset()
    {
      valid = false;
    }
 
#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
    //*************************************************************************
    //*************************************************************************
    template <typename ... Args>
    ETL_CONSTEXPR14 void emplace(Args && ... args)
    {
      storage.u.value = T(ETL_OR_STD::forward<Args>(args)...);
      valid = true;
    }
#else
    //*************************************************************************
    //*************************************************************************
    template <typename T1>
    void emplace(const T1& value1)
    {
      storage.u.value = value1;
      valid = true;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2>
    void emplace(const T1& value1, const T2& value2)
    {
      storage.u.value = T(value1, value2);
      valid = true;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2, typename T3>
    void emplace(const T1& value1, const T2& value2, const T3& value3)
    {
      storage.u.value = T(value1, value2, value3);
      valid = true;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T1, typename T2, typename T3, typename T4>
    void emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
    {
      storage.u.value = T(value1, value2, value3, value4);
      valid = true;
    }
#endif
 
  private:
 
    bool valid;
 
    struct storage_type
    {
      storage_type()
      {
      }
 
      union union_type
      {
        union_type()
          : dummy(0)
        {
        }
 
        char dummy;
        T value;
      };
 
      union_type u;
    };
 
    storage_type storage;
  };
 
#include "etl/private/diagnostic_uninitialized_push.h"
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    if (lhs.has_value() != rhs.has_value())
    {
      return false;
    }
    else if (!lhs.has_value() && !rhs.has_value())
    {
      return true;
    }
    else
    {
      return lhs.value() == rhs.value();
    }
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    if (!rhs.has_value())
    {
      return false;
    }
    else if (!lhs.has_value())
    {
      return true;
    }
    else
    {
      return lhs.value() < rhs.value();
    }
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return (rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs < rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !(lhs == etl::nullopt);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator !=(etl::nullopt_t , const etl::optional<T>& rhs)
  {
    return !(etl::nullopt == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>&, etl::nullopt_t)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator <=(etl::nullopt_t, const etl::optional<T>&)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >(etl::nullopt_t, const etl::optional<T>&)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>&, etl::nullopt_t)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 bool operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() == rhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const U& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator ==(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? rhs.value() == lhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator !=(const U& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() < rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator <(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs < rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() <= rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator <=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs <= rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() > rhs  : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator >(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs > rhs.value() : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() >= rhs : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_CONSTEXPR14 bool operator >=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs >= rhs.value() : true;
  }
 
#include "etl/private/diagnostic_pop.h"
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR14 etl::optional<typename etl::decay<T>::type> make_optional(T& value)
  {
    return etl::optional<typename etl::decay<T>::type>(value);
  }
 
  //***************************************************************************
  //***************************************************************************
#if ETL_CPP17_SUPPORTED
  template <typename T>
  optional(T) -> optional<T>;
#endif
}
 
//*************************************************************************
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14 void swap(etl::optional<T>& lhs, etl::optional<T>& rhs)
{
  lhs.swap(rhs);
}
 
#endif