std::experimental::optional< T > Class Template Reference

#include "optional.hpp"

Inheritance diagram for std::experimental::optional< T >:

Public Types
typedef T	value_type

Public Member Functions
constexpr	optional () noexcept
constexpr	optional (nullopt_t) noexcept
	optional (const optional &rhs)
	optional (optional &&rhs) noexcept(is_nothrow_move_constructible< T >::value)
constexpr	optional (const T &v)
constexpr	optional (T &&v)
template<class... Args>
constexpr	optional (in_place_t, Args &&... args)
template<class U , class... Args, TR2_OPTIONAL_REQUIRES(is_constructible< T, std::initializer_list< U > >) >
OPTIONAL_CONSTEXPR_INIT_LIST	optional (in_place_t, std::initializer_list< U > il, Args &&... args)
	~optional ()=default
optional &	operator= (nullopt_t) noexcept
optional &	operator= (const optional &rhs)
optional &	operator= (optional &&rhs) noexcept(is_nothrow_move_assignable< T >::value &&is_nothrow_move_constructible< T >::value)
template<class U >
auto	operator= (U &&v) -> typename enable_if< is_same< typename decay< U >::type, T >::value, optional & >::type
template<class... Args>
void	emplace (Args &&... args)
template<class U , class... Args>
void	emplace (initializer_list< U > il, Args &&... args)
void	swap (optional< T > &rhs) noexcept(is_nothrow_move_constructible< T >::value &&noexcept(detail_::swap_ns::adl_swap(declval< T & >(), declval< T & >())))
constexpr	operator bool () const noexcept
constexpr bool	has_value () const noexcept
constexpr T const *	operator-> () const
T *	operator-> ()
constexpr T const &	operator* () const
T &	operator* ()
constexpr T const &	value () const
T &	value ()
template<class V >
constexpr T	value_or (V &&v) const
void	reset () noexcept

Member Typedef Documentation

value_type

template<class T >

typedef T std::experimental::optional< T >::value_type

Constructor & Destructor Documentation

optional() [1/8]

template<class T >

constexpr std::experimental::optional< T >::optional ( )

inlineconstexprnoexcept

: OptionalBase<T>()  {};

optional() [2/8]

template<class T >

constexpr std::experimental::optional< T >::optional ( nullopt_t  )

inlineconstexprnoexcept

: OptionalBase<T>() {};

optional() [3/8]

template<class T >

std::experimental::optional< T >::optional ( const optional< T > &  rhs )

inline

  : OptionalBase<T>()
  {
    if (rhs.initialized()) {
        ::new (static_cast<void*>(dataptr())) T(*rhs);
        OptionalBase<T>::init_ = true;
    }
  }

optional() [4/8]

template<class T >

std::experimental::optional< T >::optional ( optional< T > &&  rhs )

inlinenoexcept

  : OptionalBase<T>()
  {
    if (rhs.initialized()) {
        ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
        OptionalBase<T>::init_ = true;
    }
  }

optional() [5/8]

template<class T >

constexpr std::experimental::optional< T >::optional ( const T &  v )

inlineconstexpr

: OptionalBase<T>(v) {}

optional() [6/8]

template<class T >

constexpr std::experimental::optional< T >::optional ( T &&  v )

inlineconstexpr

: OptionalBase<T>(constexpr_move(v)) {}

optional() [7/8]

template<class T >

template<class... Args>

constexpr std::experimental::optional< T >::optional ( in_place_t  , Args &&...  args  )

inlineexplicitconstexpr

  : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}

optional() [8/8]

template<class T >

template<class U , class... Args, TR2_OPTIONAL_REQUIRES(is_constructible< T, std::initializer_list< U > >) >

OPTIONAL_CONSTEXPR_INIT_LIST std::experimental::optional< T >::optional ( in_place_t  , std::initializer_list< U >  il, Args &&...  args  )

inlineexplicit

  : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}

~optional()

template<class T >

std::experimental::optional< T >::~optional ( )

default

Member Function Documentation

operator=() [1/4]

template<class T >

optional & std::experimental::optional< T >::operator= ( nullopt_t  )

inlinenoexcept

  {
    clear();
    return *this;
  }

operator=() [2/4]

template<class T >

optional & std::experimental::optional< T >::operator= ( const optional< T > &  rhs )

inline

  {
    if      (initialized() == true  && rhs.initialized() == false) clear();
    else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = *rhs;
    return *this;
  }

operator=() [3/4]

template<class T >

optional & std::experimental::optional< T >::operator= ( optional< T > &&  rhs )

inlinenoexcept

  {
    if      (initialized() == true  && rhs.initialized() == false) clear();
    else if (initialized() == false && rhs.initialized() == true)  initialize(std::move(*rhs));
    else if (initialized() == true  && rhs.initialized() == true)  contained_val() = std::move(*rhs);
    return *this;
  }

operator=() [4/4]

template<class T >

template<class U >

auto std::experimental::optional< T >::operator= ( U &&  v ) -> typename enable_if < is_same<typename decay<U>::type, T>::value, optional& >::type

inline

  {
    if (initialized()) { contained_val() = std::forward<U>(v); }
    else               { initialize(std::forward<U>(v));  }
    return *this;
  }

emplace() [1/2]

template<class T >

template<class... Args>

void std::experimental::optional< T >::emplace ( Args &&...  args )

inline

  {
    clear();
    initialize(std::forward<Args>(args)...);
  }

emplace() [2/2]

template<class T >

template<class U , class... Args>

void std::experimental::optional< T >::emplace ( initializer_list< U >  il, Args &&...  args  )

inline

  {
    clear();
    initialize<U, Args...>(il, std::forward<Args>(args)...);
  }

swap()

template<class T >

void std::experimental::optional< T >::swap ( optional< T > &  rhs )

inlinenoexcept

  {
    if      (initialized() == true  && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
    else if (initialized() == false && rhs.initialized() == true)  { initialize(std::move(*rhs)); rhs.clear(); }
    else if (initialized() == true  && rhs.initialized() == true)  { using std::swap; swap(**this, *rhs); }
  }

operator bool()

template<class T >

constexpr std::experimental::optional< T >::operator bool ( ) const

inlineexplicitconstexprnoexcept

{ return initialized(); }

has_value()

template<class T >

constexpr bool std::experimental::optional< T >::has_value ( ) const

inlineconstexprnoexcept

{ return initialized(); }

operator->() [1/2]

template<class T >

constexpr T const * std::experimental::optional< T >::operator-> ( ) const

inlineconstexpr

                                         {
    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
  }

operator->() [2/2]

template<class T >

T * std::experimental::optional< T >::operator-> ( )

inline

                   {
    assert (initialized());
    return dataptr();
  }

operator*() [1/2]

template<class T >

constexpr T const & std::experimental::optional< T >::operator* ( ) const

inlineconstexpr

                                        {
    return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
  }

operator*() [2/2]

template<class T >

T & std::experimental::optional< T >::operator* ( )

inline

                  {
    assert (initialized());
    return contained_val();
  }

value() [1/2]

template<class T >

constexpr T const & std::experimental::optional< T >::value ( ) const

inlineconstexpr

                                   {
    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
  }

value() [2/2]

template<class T >

T & std::experimental::optional< T >::value ( )

inline

             {
    return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
  }

value_or()

template<class T >

template<class V >

constexpr T std::experimental::optional< T >::value_or ( V &&  v ) const

inlineconstexpr

  {
    return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
  }

reset()

template<class T >

void std::experimental::optional< T >::reset ( )

inlinenoexcept

{ clear(); }

---

The documentation for this class was generated from the following file:

• include/quickcpplib/optional/optional.hpp