sol::optional< T > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::optional< T >:

Public Types
typedef T	value_type

Public Member Functions
constexpr	optional () noexcept
constexpr	optional (nullopt_t) noexcept
	optional (const optional &rhs)
	optional (const optional< T &> &rhs)
	optional (optional &&rhs) noexcept(::std::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(::std::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(::std::is_nothrow_move_assignable< T >::value &&::std::is_nothrow_move_constructible< T >::value)
template<class U >
auto	operator= (U &&v) -> typename ::std::enable_if< ::std::is_same< typename ::std::decay< U >::type, T >::value, optional &>::type
template<class... Args>
void	emplace (Args &&... args)
template<class U , class... Args>
void	emplace (::std::initializer_list< U > il, Args &&... args)
void	swap (optional< T > &rhs) noexcept(::std::is_nothrow_move_constructible< T >::value &&noexcept(swap(::std::declval< T &>(), ::std::declval< T &>())))
constexpr	operator bool () 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

Private Member Functions
constexpr bool	initialized () const noexcept
typename ::std::remove_const< T >::type *	dataptr ()
constexpr const T *	dataptr () const
constexpr const T &	contained_val () const
T &	contained_val ()
void	clear () noexcept
template<class... Args>
void	initialize (Args &&... args) noexcept(noexcept(T(::std::forward< Args >(args)...)))
template<class U , class... Args>
void	initialize (::std::initializer_list< U > il, Args &&... args) noexcept(noexcept(T(il, ::std::forward< Args >(args)...)))

Member Typedef Documentation

value_type

template<class T>

typedef T sol::optional< T >::value_type

Constructor & Destructor Documentation

optional() [1/9]

template<class T>

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

inlinenoexcept

        : OptionalBase<T>(){};

optional() [2/9]

template<class T>

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

inlinenoexcept

        : OptionalBase<T>(){};

optional() [3/9]

template<class T>

sol::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/9]

template<class T>

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

inline

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

optional() [5/9]

template<class T>

sol::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() [6/9]

template<class T>

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

inline

        : OptionalBase<T>(v) {
        }

optional() [7/9]

template<class T>

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

inline

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

optional() [8/9]

template<class T>

template<class... Args>

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

inlineexplicit

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

optional() [9/9]

template<class T>

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

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

inlineexplicit

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

~optional()

template<class T>

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

default

Member Function Documentation

clear()

template<class T>

void sol::optional< T >::clear ( )

inlineprivatenoexcept

                              {
            if (initialized())
                dataptr()->T::~T();
            OptionalBase<T>::init_ = false;
        }

contained_val() [1/2]

template<class T>

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

inlineprivate

                                                 {
            return OptionalBase<T>::storage();
        }

contained_val() [2/2]

template<class T>

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

inlineprivate

                           {
            return OptionalBase<T>::storage();
        }

dataptr() [1/2]

template<class T>

typename ::std::remove_const<T>::type* sol::optional< T >::dataptr ( )

inlineprivate

                                                   {
            return ::std::addressof(OptionalBase<T>::storage());
        }

dataptr() [2/2]

template<class T>

constexpr const T* sol::optional< T >::dataptr ( ) const

inlineprivate

                                           {
            return detail_::static_addressof(OptionalBase<T>::storage());
        }

emplace() [1/2]

template<class T>

template<class... Args>

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

inline

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

emplace() [2/2]

template<class T>

template<class U , class... Args>

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

inline

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

initialize() [1/2]

template<class T>

template<class... Args>

void sol::optional< T >::initialize ( Args &&...  args )

inlineprivatenoexcept

                                                                                         {
            assert(!OptionalBase<T>::init_);
            ::new (static_cast<void*>(dataptr())) T(::std::forward<Args>(args)...);
            OptionalBase<T>::init_ = true;
        }

initialize() [2/2]

template<class T>

template<class U , class... Args>

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

inlineprivatenoexcept

                                                                                                                        {
            assert(!OptionalBase<T>::init_);
            ::new (static_cast<void*>(dataptr())) T(il, ::std::forward<Args>(args)...);
            OptionalBase<T>::init_ = true;
        }

initialized()

template<class T>

constexpr bool sol::optional< T >::initialized ( ) const

inlineprivatenoexcept

                                                    {
            return OptionalBase<T>::init_;
        }

operator bool()

template<class T>

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

inlineexplicitnoexcept

                                                          {
            return initialized();
        }

operator*() [1/2]

template<class T>

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

inline

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

operator*() [2/2]

template<class T>

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

inline

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

operator->() [1/2]

template<class T>

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

inline

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

operator->() [2/2]

template<class T>

T* sol::optional< T >::operator-> ( )

inline

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

operator=() [1/4]

template<class T>

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

inlinenoexcept

                                                {
            clear();
            return *this;
        }

operator=() [2/4]

template<class T>

optional& sol::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& sol::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 sol::optional< T >::operator= ( U &&  v ) -> typename ::std::enable_if< ::std::is_same<typename ::std::decay<U>::type, T>::value, optional&>::type

inline

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

swap()

template<class T>

void sol::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);
            }
        }

value() [1/2]

template<class T>

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

inline

                                         {
            return initialized() ? contained_val()
#ifdef SOL_NO_EXCEPTIONS
                             // we can't abort here
                             // because there's no constexpr abort
                             : *static_cast<T*>(nullptr);
#else
                             : (throw bad_optional_access("bad optional access"), contained_val());
#endif
        }

value() [2/2]

template<class T>

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

inline

                   {
            return initialized() ? contained_val()
#ifdef SOL_NO_EXCEPTIONS
                             // we can abort here
                             // but the others are constexpr, so we can't...
                             : (std::abort(), *static_cast<T*>(nullptr));
#else
                             : (throw bad_optional_access("bad optional access"), contained_val());
#endif
        }

value_or()

template<class T>

template<class V >

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

inline

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

---

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

• external/sol.hpp