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 "error_handler.h"
#include "exception.h"
#include "initializer_list.h"
#include "memory.h"
#include "placement_new.h"
#include "type_traits.h"
#include "utility.h"
 
namespace etl
{
  //*****************************************************************************
  // Forward declaration of etl::optional
  //*****************************************************************************
  template <typename T>
  class optional;
 
  //*****************************************************************************
  //*****************************************************************************
  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_)
    {
    }
  };
 
  //*****************************************************************************
  // Implementations for fundamental and non fundamental types.
  //*****************************************************************************
  namespace private_optional
  {
    template <typename T, bool UseFundamentalPath = etl::is_fundamental<T>::value && !etl::is_const<T>::value>
    class optional_impl;
 
    //*****************************************************************************
    // Implementation for non fundamental types.
    //*****************************************************************************
    template <typename T>
    class optional_impl<T, false>
    {
    protected:
 
      typedef T                       value_type;
      typedef optional_impl<T, false> this_type;
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl() ETL_NOEXCEPT
        : storage()
      {
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl(etl::nullopt_t) ETL_NOEXCEPT
        : storage()
      {
      }
 
#include "private/diagnostic_uninitialized_push.h"
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl(const optional_impl& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
      {
        if (other.has_value())
        {
          storage.construct(other.value());
        }
      }
#include "private/diagnostic_pop.h"
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl(optional_impl&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
      {
        if (other.has_value())
        {
          storage.construct(etl::move(other.value()));
        }
      }
 
      //***************************************************************************
      //***************************************************************************
      template <typename U,
                typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::in_place_t>::value
                                           && !etl::is_same<typename etl::decay<U>::type, optional_impl>::value,
                                         int>::type = 0>
      ETL_CONSTEXPR20_STL optional_impl(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
      {
        storage.construct(etl::forward<U>(value_));
      }
 
      //***************************************************************************
      //***************************************************************************
      template <typename... TArgs>
      ETL_CONSTEXPR20_STL optional_impl(etl::in_place_t, TArgs&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, TArgs...>::value))
      {
        storage.construct(etl::forward<TArgs>(args)...);
      }
 
  #if ETL_HAS_INITIALIZER_LIST
      //*******************************************
      //*******************************************
      template <typename U, typename... TArgs >
      ETL_CONSTEXPR20_STL optional_impl(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
        ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>&, TArgs...>::value))
      {
        storage.construct(ilist, etl::forward<TArgs>(args)...);
      }
  #endif
#endif
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      ~optional_impl() ETL_NOEXCEPT
      {
        storage.destroy();
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl& operator=(etl::nullopt_t) ETL_NOEXCEPT
      {
        if (has_value())
        {
          storage.destroy();
        }
 
        return *this;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl& operator=(const optional_impl& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
      {
        if (this != &other)
        {
          if (other.has_value())
          {
            storage.construct(other.value());
          }
          else
          {
            storage.destroy();
          }
        }
 
        return *this;
      }
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      optional_impl& operator=(optional_impl&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
      {
        if (this != &other)
        {
          if (other.has_value())
          {
            storage.construct(etl::move(other.value()));
          }
          else
          {
            storage.destroy();
          }
        }
 
        return *this;
      }
#endif
 
      //***************************************************************************
      //***************************************************************************
#if ETL_USING_CPP11
      template <typename U,
                typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, optional_impl>::value,
                                         int>::type = 0>
      ETL_CONSTEXPR20_STL optional_impl& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
      {
        storage.construct(etl::forward<U>(value_));
 
        return *this;
      }
#else
      ETL_CONSTEXPR20_STL
      optional_impl& operator=(const T& value_)
      {
        storage.construct(value_);
 
        return *this;
      }
#endif
 
    public:
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      T* operator->()
      {
#if ETL_IS_DEBUG_BUILD
        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_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_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_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_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_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() : 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) &&
      {
        return has_value() ? etl::move(value()) : static_cast<T>(etl::forward<U>(default_value));
      }
#endif
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      void swap(optional_impl& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
      {
        optional_impl temp(ETL_MOVE(*this));
        *this = ETL_MOVE(other);
        other = ETL_MOVE(temp);
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR20_STL
      void reset() ETL_NOEXCEPT
      {
        storage.destroy();
      }
 
#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
      //*************************************************************************
      //*************************************************************************
      template <typename... Args>
      ETL_CONSTEXPR20_STL T& emplace(Args&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
      {
        storage.construct(etl::forward<Args>(args)...);
 
        return storage.u.value;
      }
 
  #if ETL_HAS_INITIALIZER_LIST
      //*******************************************
      //*******************************************
      template <typename U, typename... Args,
                typename etl::enable_if< etl::is_constructible<T, std::initializer_list<U>&, Args...>::value, int>::type = 0 >
      ETL_CONSTEXPR20_STL T& emplace(std::initializer_list<U> ilist, Args&&... args)
        ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>&, Args...>::value))
      {
        storage.construct(ilist, etl::forward<Args>(args)...);
 
        return storage.u.value;
      }
  #endif
#else
      //*************************************************************************
      //*************************************************************************
      T& emplace() ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T>::value))
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.u.value) T();
        storage.valid = true;
 
        return *p;
      }
 
      //*************************************************************************
      //*************************************************************************
      template <typename T1>
      T& emplace(const T1& value1) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, T1>::value))
      {
        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) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, T1, T2>::value))
      {
        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) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, T1, T2, T3>::value))
      {
        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)
        ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, T1, T2, T3, T4>::value))
      {
        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 dummy_t
      {
      };
 
      //*************************************
      // The storage for the optional value.
      //*************************************
      struct storage_type
      {
        typedef typename etl::remove_const<T>::type* pointer_type;
 
        //*******************************
        ETL_CONSTEXPR20_STL
        storage_type()
          : u()
          , valid(false)
        {
        }
 
        //*******************************
        ETL_CONSTEXPR20_STL
        void construct(const T& value_)
        {
          destroy();
 
          etl::construct_at(const_cast<pointer_type>(&u.value), value_);
          valid = true;
        }
 
#if ETL_USING_CPP11
        //*******************************
        ETL_CONSTEXPR20_STL
        void construct(T&& value_)
        {
          destroy();
 
          etl::construct_at(const_cast<pointer_type>(&u.value), etl::move(value_));
          valid = true;
        }
 
        //*******************************
        template <typename... TArgs>
        ETL_CONSTEXPR20_STL void construct(TArgs&&... args)
        {
          destroy();
 
          etl::construct_at(const_cast<pointer_type>(&u.value), etl::forward<TArgs>(args)...);
          valid = true;
        }
#endif
 
        //*******************************
        ETL_CONSTEXPR20_STL
        void destroy()
        {
          if (valid)
          {
            etl::destroy_at(const_cast<pointer_type>(&u.value));
            valid = false;
          }
        }
 
        //*******************************
        union union_type
        {
          ETL_CONSTEXPR20_STL
          union_type()
            : dummy()
          {
          }
 
          ETL_CONSTEXPR20_STL
          ~union_type() {}
 
          dummy_t dummy;
          T       value;
        } u;
 
        bool valid;
      };
 
      storage_type storage;
    };
 
    //*****************************************************************************
    // Implementation for fundamental types.
    //*****************************************************************************
    template <typename T>
    class optional_impl<T, true>
    {
    protected:
 
      typedef T                      value_type;
      typedef optional_impl<T, true> this_type;
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl() ETL_NOEXCEPT
        : storage()
      {
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl(etl::nullopt_t) ETL_NOEXCEPT
        : storage()
      {
      }
 
#include "private/diagnostic_uninitialized_push.h"
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl(const optional_impl& other) ETL_NOEXCEPT
      {
        if (other.has_value())
        {
          storage.construct(other.value());
        }
      }
#include "private/diagnostic_pop.h"
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl(optional_impl&& other) ETL_NOEXCEPT
      {
        if (other.has_value())
        {
          storage.construct(etl::move(other.value()));
        }
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl(const T& value_) ETL_NOEXCEPT
      {
        storage.construct(value_);
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl(T&& value_) ETL_NOEXCEPT
      {
        storage.construct(etl::move(value_));
      }
 
      //***************************************************************************
      //***************************************************************************
      template <typename... TArgs>
      ETL_CONSTEXPR14 optional_impl(etl::in_place_t, TArgs&&... args) ETL_NOEXCEPT
      {
        storage.construct(etl::forward<TArgs>(args)...);
      }
 
  #if ETL_HAS_INITIALIZER_LIST
      //*******************************************
      //*******************************************
      template <typename U, typename... TArgs >
      ETL_CONSTEXPR14 optional_impl(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args) ETL_NOEXCEPT
      {
        storage.construct(ilist, etl::forward<TArgs>(args)...);
      }
  #endif
#endif
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl& operator=(etl::nullopt_t) ETL_NOEXCEPT
      {
        if (has_value())
        {
          storage.destroy();
        }
 
        return *this;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl& operator=(const optional_impl& other) ETL_NOEXCEPT
      {
        if (this != &other)
        {
          if (other.has_value())
          {
            storage.construct(other.value());
          }
          else
          {
            storage.destroy();
          }
        }
 
        return *this;
      }
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl& operator=(optional_impl&& other) ETL_NOEXCEPT
      {
        if (this != &other)
        {
          if (other.has_value())
          {
            storage.construct(etl::move(other.value()));
          }
          else
          {
            storage.destroy();
          }
        }
 
        return *this;
      }
#endif
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl& operator=(const T& value_) ETL_NOEXCEPT
      {
        storage.construct(value_);
 
        return *this;
      }
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 optional_impl& operator=(T&& value_) ETL_NOEXCEPT
      {
        storage.construct(etl::move(value_));
 
        return *this;
      }
#endif
 
    public:
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T* operator->()
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return &storage.value;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 const T* operator->() const
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return &storage.value;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T& operator*() ETL_LVALUE_REF_QUALIFIER
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return storage.value;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 const T& operator*() const ETL_LVALUE_REF_QUALIFIER
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return storage.value;
      }
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T&& operator*() &&
      {
  #if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
  #endif
 
        return etl::move(storage.value);
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 const T&& operator*() const&&
      {
  #if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
  #endif
 
        return etl::move(storage.value);
      }
#endif
 
      //***************************************************************************
      // Check whether optional contains value
      //***************************************************************************
      ETL_CONSTEXPR14 bool has_value() const ETL_NOEXCEPT
      {
        return storage.valid;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 ETL_EXPLICIT operator bool() const
      {
        return has_value();
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T& value() ETL_LVALUE_REF_QUALIFIER
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return storage.value;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 const T& value() const ETL_LVALUE_REF_QUALIFIER
      {
#if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
 
        return storage.value;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
      {
        return has_value() ? value() : default_value;
      }
 
#if ETL_USING_CPP11
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 T&& value() &&
      {
  #if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
  #endif
 
        return etl::move(storage.value);
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 const T&& value() const&&
      {
  #if ETL_IS_DEBUG_BUILD
        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
  #endif
 
        return etl::move(storage.value);
      }
 
      //***************************************************************************
      //***************************************************************************
      template <typename U>
      ETL_CONSTEXPR14 etl::enable_if_t<etl::is_convertible<U, T>::value, T> value_or(U&& default_value) const&
      {
        return has_value() ? value() : static_cast<T>(etl::forward<U>(default_value));
      }
 
      //***************************************************************************
      //***************************************************************************
      template <typename U>
      ETL_CONSTEXPR14 etl::enable_if_t<etl::is_convertible<U, T>::value, T> value_or(U&& default_value) &&
      {
        return has_value() ? etl::move(value()) : static_cast<T>(etl::forward<U>(default_value));
      }
#endif
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 void swap(optional_impl& other) ETL_NOEXCEPT
      {
        optional_impl temp(*this);
        *this = other;
        other = temp;
      }
 
      //***************************************************************************
      //***************************************************************************
      ETL_CONSTEXPR14 void reset() ETL_NOEXCEPT
      {
        storage.destroy();
      }
 
#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
      //*************************************************************************
      //*************************************************************************
      template <typename... TArgs>
      ETL_CONSTEXPR14 T& emplace(TArgs&&... args) ETL_NOEXCEPT
      {
        storage.construct(etl::forward<TArgs>(args)...);
 
        return storage.value;
      }
#else
      //*************************************************************************
      //*************************************************************************
      T& emplace() ETL_NOEXCEPT
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.value) T();
        storage.valid = true;
 
        return *p;
      }
 
      //*************************************************************************
      //*************************************************************************
      template <typename T1>
      T& emplace(const T1& value1) ETL_NOEXCEPT
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.value) T(value1);
        storage.valid = true;
 
        return *p;
      }
 
      //*************************************************************************
      //*************************************************************************
      template <typename T1, typename T2>
      T& emplace(const T1& value1, const T2& value2) ETL_NOEXCEPT
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.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) ETL_NOEXCEPT
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.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) ETL_NOEXCEPT
      {
        if (has_value())
        {
          // Destroy the old one.
          storage.destroy();
        }
 
        T* p          = ::new (&storage.value) T(value1, value2, value3, value4);
        storage.valid = true;
 
        return *p;
      }
#endif
 
    private:
 
      //*************************************
      // The storage for the optional value.
      //*************************************
      struct storage_type
      {
        //*******************************
        ETL_CONSTEXPR14 storage_type()
          : value()
          , valid(false)
        {
        }
 
        //*******************************
        ETL_CONSTEXPR14 void construct(const T& value_)
        {
          value = value_;
          valid = true;
        }
 
#if ETL_USING_CPP11
        //*******************************
        ETL_CONSTEXPR14 void construct(T&& value_)
        {
          value = value_;
          valid = true;
        }
 
        //*******************************
        template <typename... TArgs>
        ETL_CONSTEXPR14 void construct(TArgs&&... args)
        {
          value = T(etl::forward<TArgs>(args)...);
          valid = true;
        }
#endif
 
        //*******************************
        ETL_CONSTEXPR14 void destroy()
        {
          valid = false;
        }
 
        T    value;
        bool valid;
      };
 
      storage_type storage;
    };
  } // namespace private_optional
 
#define ETL_OPTIONAL_ENABLE_CPP14     typename etl::enable_if< etl::is_pod<typename etl::remove_cv<U>::type>::value, int>::type = 0
#define ETL_OPTIONAL_ENABLE_CPP20_STL typename etl::enable_if< !etl::is_pod<typename etl::remove_cv<U>::type>::value, int>::type = 0
 
#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 \
  ETL_CONSTEXPR14 typename etl::enable_if< etl::is_pod<typename etl::remove_cv<T>::type>::value, bool>::type
#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL \
  ETL_CONSTEXPR20_STL                                       \
  typename etl::enable_if< !etl::is_pod<typename etl::remove_cv<T>::type>::value, bool>::type
 
  //*****************************************************************************
  //*****************************************************************************
  template <typename T>
  class optional : public private_optional::optional_impl<T>
  {
  private:
 
    typedef private_optional::optional_impl<T> impl_t;
 
  public:
 
    typedef T        value_type;
    typedef T*       iterator;
    typedef const T* const_iterator;
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
    ETL_CONSTEXPR14 optional() ETL_NOEXCEPT
      : impl_t()
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
    ETL_CONSTEXPR20_STL optional() ETL_NOEXCEPT
      : impl_t()
    {
    }
#else
    optional() ETL_NOEXCEPT
      : impl_t()
    {
    }
#endif
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
    ETL_CONSTEXPR14 optional(etl::nullopt_t) ETL_NOEXCEPT
      : impl_t(etl::nullopt)
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
    ETL_CONSTEXPR20_STL optional(etl::nullopt_t) ETL_NOEXCEPT
      : impl_t(etl::nullopt)
    {
    }
#else
    //***************************************************************************
    //***************************************************************************
    optional(etl::nullopt_t) ETL_NOEXCEPT
      : impl_t(etl::nullopt)
    {
    }
#endif
 
#include "private/diagnostic_uninitialized_push.h"
 
#if ETL_USING_CPP11
#else
    //***************************************************************************
    //***************************************************************************
    optional(const optional& other)
      : impl_t(other)
    {
    }
#endif
#include "private/diagnostic_pop.h"
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template < typename U,
               typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::optional<T>>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::in_place_t>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
                                          && etl::is_pod<typename etl::remove_cv<T>::type>::value,
                                        int>::type = 0>
    ETL_CONSTEXPR14 optional(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
      : impl_t(etl::forward<U>(value_))
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    template < typename U,
               typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::optional<T>>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::in_place_t>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
                                          && !etl::is_pod<typename etl::remove_cv<T>::type>::value,
                                        int>::type = 0>
    ETL_CONSTEXPR20_STL optional(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
      : impl_t(etl::forward<U>(value_))
    {
    }
#else
    //***************************************************************************
    //***************************************************************************
    optional(const T& value_)
      : impl_t(value_)
    {
    }
#endif
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14, typename... Args>
    ETL_CONSTEXPR14 explicit optional(etl::in_place_t, Args&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
      : impl_t(etl::in_place_t{}, etl::forward<Args>(args)...)
    {
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL, typename... Args>
    ETL_CONSTEXPR20_STL explicit optional(etl::in_place_t, Args&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
      : impl_t(etl::in_place_t{}, etl::forward<Args>(args)...)
    {
    }
 
  #if ETL_HAS_INITIALIZER_LIST
    //*******************************************
    //*******************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14, typename... TArgs>
    ETL_CONSTEXPR14 explicit optional(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
      ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>&, TArgs...>::value))
      : impl_t(etl::in_place_t{}, ilist, etl::forward<TArgs>(args)...)
    {
    }
 
    //*******************************************
    //*******************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL, typename... TArgs>
    ETL_CONSTEXPR20_STL explicit optional(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
      ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>&, TArgs...>::value))
      : impl_t(etl::in_place_t{}, ilist, etl::forward<TArgs>(args)...)
    {
    }
  #endif
#endif
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
    ETL_CONSTEXPR14 optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
    {
      impl_t::operator=(etl::nullopt);
 
      return *this;
    }
 
    //***************************************************************************
    //***************************************************************************
    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
    ETL_CONSTEXPR20_STL optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
    {
      impl_t::operator=(etl::nullopt);
 
      return *this;
    }
#else
    //***************************************************************************
    //***************************************************************************
    optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
    {
      impl_t::operator=(etl::nullopt);
 
      return *this;
    }
#endif
 
#if ETL_USING_CPP11
#else
    //***************************************************************************
    //***************************************************************************
    optional& operator=(const optional& other)
    {
      impl_t::operator=(other);
 
      return *this;
    }
#endif
 
#if ETL_USING_CPP11
    //***************************************************************************
    //***************************************************************************
    template < typename U,
               typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::optional<T>>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
                                          && etl::is_pod<typename etl::remove_cv<T>::type>::value,
                                        int>::type = 0>
    ETL_CONSTEXPR14 optional& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
    {
      impl_t::operator=(etl::forward<U>(value_));
 
      return *this;
    }
 
    //***************************************************************************
    //***************************************************************************
    template < typename U,
               typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::optional<T>>::value
                                          && !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
                                          && !etl::is_pod<typename etl::remove_cv<T>::type>::value,
                                        int>::type = 0>
    ETL_CONSTEXPR20_STL optional& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
    {
      impl_t::operator=(etl::forward<U>(value_));
 
      return *this;
    }
#else
    //***************************************************************************
    //***************************************************************************
    optional& operator=(const T& value_)
    {
      impl_t::operator=(value_);
 
      return *this;
    }
#endif
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    iterator begin() ETL_NOEXCEPT
    {
      return this->has_value() ? this->operator->() : ETL_NULLPTR;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const_iterator begin() const ETL_NOEXCEPT
    {
      return this->has_value() ? this->operator->() : ETL_NULLPTR;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    iterator end() ETL_NOEXCEPT
    {
      return this->has_value() ? this->operator->() + 1 : ETL_NULLPTR;
    }
 
    //***************************************************************************
    //***************************************************************************
    ETL_CONSTEXPR20_STL
    const_iterator end() const ETL_NOEXCEPT
    {
      return this->has_value() ? this->operator->() + 1 : ETL_NULLPTR;
    }
  };
 
#include "private/diagnostic_uninitialized_push.h"
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 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_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL 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_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 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_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL 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_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return (rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return (rhs < lhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs < rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs < rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator==(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator==(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator==(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator==(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !(lhs == etl::nullopt);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !(lhs == etl::nullopt);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!=(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !(etl::nullopt == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!=(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !(etl::nullopt == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<(const etl::optional<T>&, etl::nullopt_t)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<(const etl::optional<T>&, etl::nullopt_t)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<=(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return !lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<=(etl::nullopt_t, const etl::optional<T>&)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<=(etl::nullopt_t, const etl::optional<T>&)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>(const etl::optional<T>& lhs, etl::nullopt_t)
  {
    return lhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>(etl::nullopt_t, const etl::optional<T>&)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>(etl::nullopt_t, const etl::optional<T>&)
  {
    return false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>=(const etl::optional<T>&, etl::nullopt_t)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>=(const etl::optional<T>&, etl::nullopt_t)
  {
    return true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>=(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>=(etl::nullopt_t, const etl::optional<T>& rhs)
  {
    return !rhs.has_value();
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator==(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() == rhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator==(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() == rhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!=(const etl::optional<T>& lhs, const U& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!=(const etl::optional<T>& lhs, const U& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator==(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? rhs.value() == lhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator==(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? rhs.value() == lhs : false;
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!=(const U& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //**************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!=(const U& lhs, const etl::optional<T>& rhs)
  {
    return !(lhs == rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() < rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() < rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs < rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs < rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() <= rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() <= rhs : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs <= rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs <= rhs.value() : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() > rhs : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() > rhs : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs > rhs.value() : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs > rhs.value() : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() >= rhs : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>=(const etl::optional<T>& lhs, const U& rhs)
  {
    return lhs.has_value() ? lhs.value() >= rhs : false;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs >= rhs.value() : true;
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U>
  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>=(const U& lhs, const etl::optional<T>& rhs)
  {
    return rhs.has_value() ? lhs >= rhs.value() : true;
  }
 
#include "private/diagnostic_pop.h"
 
#if ETL_CPP11_SUPPORTED
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
  ETL_CONSTEXPR14 etl::optional<typename etl::decay<T>::type> make_optional(T&& value) //
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<typename etl::decay<T>::type, T&&>::value))
  {
    return etl::optional<typename etl::decay<T>::type>(etl::forward<T>(value));
  }
  template <typename T, typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
  ETL_CONSTEXPR20_STL etl::optional<typename etl::decay<T>::type> make_optional(T&& value) //
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<typename etl::decay<T>::type, T&&>::value))
  {
    return etl::optional<typename etl::decay<T>::type>(etl::forward<T>(value));
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename... Args,                                                      //
            typename etl::enable_if< etl::is_constructible<T, Args...>::value, int>::type = 0, //
            typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
  ETL_CONSTEXPR14 etl::optional<T> make_optional(Args&&... args)                                     //
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
  {
    return etl::optional<T>(etl::in_place_t{}, etl::forward<Args>(args)...);
  }
  template <typename T, typename... Args,                                                      //
            typename etl::enable_if< etl::is_constructible<T, Args...>::value, int>::type = 0, //
            typename U                                                                    = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
  ETL_CONSTEXPR20_STL etl::optional<T> make_optional(Args&&... args) //
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
  {
    return etl::optional<T>(etl::in_place_t{}, etl::forward<Args>(args)...);
  }
 
  #if ETL_HAS_INITIALIZER_LIST
  //***************************************************************************
  //***************************************************************************
  template <typename T, typename TL, typename... Args,                                                                     //
            typename etl::enable_if< etl::is_constructible<T, std::initializer_list<TL>&, Args...>::value, int>::type = 0, //
            typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
  ETL_CONSTEXPR14 etl::optional<T> make_optional(std::initializer_list<TL> ilist, Args&&... args)
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<TL>&, Args...>::value))
  {
    return etl::optional<T>(etl::in_place_t{}, ilist, etl::forward<Args>(args)...);
  }
  template <typename T, typename TL, typename... Args,                                                                     //
            typename etl::enable_if< etl::is_constructible<T, std::initializer_list<TL>&, Args...>::value, int>::type = 0, //
            typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
  ETL_CONSTEXPR20_STL etl::optional<T> make_optional(std::initializer_list<TL> ilist, Args&&... args)
    ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<TL>&, Args...>::value))
  {
    return etl::optional<T>(etl::in_place_t{}, ilist, etl::forward<Args>(args)...);
  }
  #endif
#else
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  ETL_CONSTEXPR20_STL etl::optional<typename etl::decay<T>::type> make_optional(T& value)
  {
    return etl::optional<typename etl::decay<T>::type>(value);
  }
#endif
 
  //***************************************************************************
  //***************************************************************************
#if ETL_CPP17_SUPPORTED
  template <typename T>
  optional(T) -> optional<T>;
#endif
 
  //*************************************************************************
  //*************************************************************************
  template <typename T>
  ETL_CONSTEXPR20_STL void swap(etl::optional<T>& lhs, etl::optional<T>& rhs) ETL_NOEXCEPT_FROM(lhs.swap(rhs))
  {
    lhs.swap(rhs);
  }
 
} // namespace etl
 
#undef ETL_OPTIONAL_ENABLE_CPP14
#undef ETL_OPTIONAL_ENABLE_CPP20_STL
 
#undef ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14
#undef ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL
 
#endif