sol::optional< T & > Class Template Reference

#include <sol.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 ::std::enable_if< ::std::is_same< typename ::std::decay< U >::type, optional< T &>>::value, optional &>::type
template<typename U >
auto	operator= (U &&rhs) noexcept -> typename ::std::enable_if< !::std::is_same< typename ::std::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
template<typename V >
constexpr T &	value_or (V &&v) const

Private Attributes
T *	ref

Constructor & Destructor Documentation

optional() [1/7]

template<class T >

constexpr sol::optional< T & >::optional ( )

inlinenoexcept

        : ref(nullptr) {
        }

optional() [2/7]

template<class T >

constexpr sol::optional< T & >::optional ( nullopt_t  )

inlinenoexcept

        : ref(nullptr) {
        }

optional() [3/7]

template<class T >

constexpr sol::optional< T & >::optional ( T &  v )

inlinenoexcept

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

optional() [4/7]

template<class T >

sol::optional< T & >::optional ( T &&  )

delete

optional() [5/7]

template<class T >

constexpr sol::optional< T & >::optional ( const optional< T & > &  rhs )

inlinenoexcept

        : ref(rhs.ref) {
        }

optional() [6/7]

template<class T >

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

inlineexplicitnoexcept

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

optional() [7/7]

template<class T >

sol::optional< T & >::optional ( in_place_t  , T &&    )

explicitdelete

~optional()

template<class T >

sol::optional< T & >::~optional ( )

default

Member Function Documentation

emplace() [1/2]

template<class T >

void sol::optional< T & >::emplace ( T &  v )

inlinenoexcept

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

emplace() [2/2]

template<class T >

void sol::optional< T & >::emplace ( T &&  )

delete

operator bool()

template<class T >

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

inlineexplicitnoexcept

                                                          {
            return ref != nullptr;
        }

operator*()

template<class T >

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

inline

                                       {
            return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
        }

operator->()

template<class T >

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

inline

                                        {
            return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
        }

operator=() [1/3]

template<class T >

optional& sol::optional< T & >::operator= ( nullopt_t  )

inlinenoexcept

                                                {
            ref = nullptr;
            return *this;
        }

operator=() [2/3]

template<class T >

template<typename U >

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

inlinenoexcept

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

operator=() [3/3]

template<class T >

template<typename U >

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

deletenoexcept

swap()

template<class T >

void sol::optional< T & >::swap ( optional< T &> &  rhs )

inlinenoexcept

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

value()

template<class T >

constexpr T& sol::optional< T & >::value ( ) const

inline

                                   {
#ifdef SOL_NO_EXCEPTIONS
            return *ref;
#else
            return ref ? *ref
                     : (throw bad_optional_access("bad optional access"), *ref);
#endif // Exceptions
        }

value_or()

template<class T >

template<typename V >

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

inline

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

Member Data Documentation

ref

template<class T >

T* sol::optional< T & >::ref

private

---

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

• external/sol.hpp