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

#include "optional.hpp"

Public Member Functions
constexpr	optional () noexcept
constexpr	optional (nullopt_t) noexcept
constexpr	optional (T &v) noexcept
	optional (T &&)=delete
constexpr	optional (const optional &rhs) noexcept
constexpr	optional (in_place_t, T &v) noexcept
	optional (in_place_t, T &&)=delete
	~optional ()=default
optional &	operator= (nullopt_t) noexcept
template<typename U >
auto	operator= (U &&rhs) noexcept -> typename enable_if< is_same< typename decay< U >::type, optional< T & > >::value, optional & >::type
template<typename U >
auto	operator= (U &&rhs) noexcept -> typename enable_if< !is_same< typename decay< U >::type, optional< T & > >::value, optional & >::type=delete
void	emplace (T &v) noexcept
void	emplace (T &&)=delete
void	swap (optional< T & > &rhs) noexcept
constexpr T *	operator-> () const
constexpr T &	operator* () const
constexpr T &	value () const
constexpr	operator bool () const noexcept
constexpr bool	has_value () const noexcept
template<class V >
constexpr decay< T >::type	value_or (V &&v) const
void	reset () noexcept

Constructor & Destructor Documentation

optional() [1/7]

template<class T >

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

inlineconstexprnoexcept

: ref(nullptr) {}

optional() [2/7]

template<class T >

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

inlineconstexprnoexcept

: ref(nullptr) {}

optional() [3/7]

template<class T >

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

inlineconstexprnoexcept

: ref(detail_::static_addressof(v)) {}

optional() [4/7]

template<class T >

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

delete

optional() [5/7]

template<class T >

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

inlineconstexprnoexcept

: ref(rhs.ref) {}

optional() [6/7]

template<class T >

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

inlineexplicitconstexprnoexcept

: ref(detail_::static_addressof(v)) {}

optional() [7/7]

template<class T >

std::experimental::optional< T & >::optional ( in_place_t  , T &&    )

explicitdelete

~optional()

template<class T >

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

default

Member Function Documentation

operator=() [1/3]

template<class T >

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

inlinenoexcept

                                          {
    ref = nullptr;
    return *this;
  }

operator=() [2/3]

template<class T >

template<typename U >

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

inlinenoexcept

  {
    ref = rhs.ref;
    return *this;
  }

operator=() [3/3]

template<class T >

template<typename U >

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

deletenoexcept

emplace() [1/2]

template<class T >

void std::experimental::optional< T & >::emplace ( T &  v )

inlinenoexcept

                              {
    ref = detail_::static_addressof(v);
  }

emplace() [2/2]

template<class T >

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

delete

swap()

template<class T >

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

inlinenoexcept

  {
    std::swap(ref, rhs.ref);
  }

operator->()

template<class T >

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

inlineconstexpr

                                  {
    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
  }

operator*()

template<class T >

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

inlineconstexpr

                                 {
    return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
  }

value()

template<class T >

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

inlineconstexpr

                             {
    return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
  }

operator bool()

template<class T >

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

inlineexplicitconstexprnoexcept

                                                    {
    return ref != nullptr;
  }

has_value()

template<class T >

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

inlineconstexprnoexcept

                                            {
    return ref != nullptr;
  }

value_or()

template<class T >

template<class V >

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

inlineconstexpr

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

reset()

template<class T >

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

inlinenoexcept

{ ref = nullptr; }

---

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

• include/quickcpplib/optional/optional.hpp