#include <sol.hpp>

Inheritance diagram for sol::optional< T >:

Collaboration diagram for sol::optional< T >:

Public Types
using	value_type = T

Public Member Functions
template<class F >
SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t< F, T & >	and_then (F &&f) &

template<class F >
SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t< F, T && >	and_then (F &&f) &&

template<class F >
constexpr detail::invoke_result_t< F, const T & >	and_then (F &&f) const &

template<class F >
constexpr detail::invoke_result_t< F, const T && >	and_then (F &&f) const &&

template<class F , detail::enable_if_ret_void< F > * = nullptr>
optional< T > SOL_TL_OPTIONAL_11_CONSTEXPR	or_else (F &&f) &
	Calls `f` if the optional is empty `std::invoke_result_t<F>` must be void or convertible to `optional<T>`. If `this` has a value, returns `this`. Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`. More...

template<class F , detail::disable_if_ret_void< F > * = nullptr>
optional< T > SOL_TL_OPTIONAL_11_CONSTEXPR	or_else (F &&f) &

template<class F , detail::enable_if_ret_void< F > * = nullptr>
optional< T >	or_else (F &&f) &&

template<class F , detail::disable_if_ret_void< F > * = nullptr>
optional< T > SOL_TL_OPTIONAL_11_CONSTEXPR	or_else (F &&f) &&

template<class F , detail::enable_if_ret_void< F > * = nullptr>
optional< T >	or_else (F &&f) const &

template<class F , detail::disable_if_ret_void< F > * = nullptr>
optional< T > SOL_TL_OPTIONAL_11_CONSTEXPR	or_else (F &&f) const &

template<class F , detail::enable_if_ret_void< F > * = nullptr>
optional< T >	or_else (F &&f) const &&

template<class F , detail::disable_if_ret_void< F > * = nullptr>
optional< T >	or_else (F &&f) const &&

template<class F , class U >
U	map_or (F &&f, U &&u) &
	Maps the stored value with `f` if there is one, otherwise returns `u`. More...

template<class F , class U >
U	map_or (F &&f, U &&u) &&
	map_or

template<class F , class U >
U	map_or (F &&f, U &&u) const &
	map_or

template<class F , class U >
U	map_or (F &&f, U &&u) const &&
	map_or

template<class F , class U >
detail::invoke_result_t< U >	map_or_else (F &&f, U &&u) &
	Maps the stored value with `f` if there is one, otherwise calls `u` and returns the result. More...

template<class F , class U >
detail::invoke_result_t< U >	map_or_else (F &&f, U &&u) &&

template<class F , class U >
detail::invoke_result_t< U >	map_or_else (F &&f, U &&u) const &

template<class F , class U >
detail::invoke_result_t< U >	map_or_else (F &&f, U &&u) const &&

template<class U >
constexpr optional< typename std::decay< U >::type >	conjunction (U &&u) const

SOL_TL_OPTIONAL_11_CONSTEXPR optional	disjunction (const optional &rhs) &

constexpr optional	disjunction (const optional &rhs) const &
	disjunction

SOL_TL_OPTIONAL_11_CONSTEXPR optional	disjunction (const optional &rhs) &&
	disjunction

constexpr optional	disjunction (const optional &rhs) const &&
	disjunction

SOL_TL_OPTIONAL_11_CONSTEXPR optional	disjunction (optional &&rhs) &
	disjunction

constexpr optional	disjunction (optional &&rhs) const &
	disjunction

SOL_TL_OPTIONAL_11_CONSTEXPR optional	disjunction (optional &&rhs) &&
	disjunction

constexpr optional	disjunction (optional &&rhs) const &&
	disjunction

optional	take () &

optional	take () const &
	take

optional	take () &&
	take

optional	take () const &&
	take

constexpr	optional () noexcept=default

constexpr	optional (nullopt_t) noexcept
	ctor_empty

SOL_TL_OPTIONAL_11_CONSTEXPR	optional (const optional &rhs)=default

SOL_TL_OPTIONAL_11_CONSTEXPR	optional (optional &&rhs)=default

template<class... Args>
constexpr	optional (detail::enable_if_t< std::is_constructible< T, Args... >::value, in_place_t >, Args &&... args)

template<class U , class... Args>
SOL_TL_OPTIONAL_11_CONSTEXPR	optional (detail::enable_if_t< std::is_constructible< T, std::initializer_list< U > &, Args &&... >::value, in_place_t >, std::initializer_list< U > il, Args &&... args)

constexpr	optional (T &&u)

constexpr	optional (const T &u)

template<class U , detail::enable_from_other< T, U, const U &> * = nullptr, detail::enable_if_t< std::is_convertible< const U &, T >::value > * = nullptr>
	optional (const optional< U > &rhs)

template<class U , detail::enable_from_other< T, U, const U &> * = nullptr, detail::enable_if_t<!std::is_convertible< const U &, T >::value > * = nullptr>
	optional (const optional< U > &rhs)

template<class U , detail::enable_from_other< T, U, U &&> * = nullptr, detail::enable_if_t< std::is_convertible< U &&, T >::value > * = nullptr>
	optional (optional< U > &&rhs)

template<class U , detail::enable_from_other< T, U, U &&> * = nullptr, detail::enable_if_t<!std::is_convertible< U &&, T >::value > * = nullptr>
	optional (optional< U > &&rhs)

	~optional ()=default
	Destroys the stored value if there is one.

optional &	operator= (nullopt_t) noexcept

optional &	operator= (const optional &rhs)=default

optional &	operator= (optional &&rhs)=default

template<class U = T, detail::enable_assign_forward< T, U > * = nullptr>
optional &	operator= (U &&u)

template<class U , detail::enable_assign_from_other< T, U, const U &> * = nullptr>
optional &	operator= (const optional< U > &rhs)

template<class U , detail::enable_assign_from_other< T, U, U > * = nullptr>
optional &	operator= (optional< U > &&rhs)

template<class... Args>
T &	emplace (Args &&... args)

template<class U , class... Args>
detail::enable_if_t< std::is_constructible< T, std::initializer_list< U > &, Args &&... >::value, T & >	emplace (std::initializer_list< U > il, Args &&... args)

void	swap (optional &rhs) noexcept(std::is_nothrow_move_constructible< T >::value &&detail::is_nothrow_swappable< T >::value)

constexpr const T *	operator-> () const

SOL_TL_OPTIONAL_11_CONSTEXPR T *	operator-> ()

SOL_TL_OPTIONAL_11_CONSTEXPR T &	operator* () &

constexpr const T &	operator* () const &

SOL_TL_OPTIONAL_11_CONSTEXPR T &&	operator* () &&

constexpr const T &&	operator* () const &&

constexpr bool	has_value () const noexcept

constexpr	operator bool () const noexcept
	has_value

SOL_TL_OPTIONAL_11_CONSTEXPR T &	value () &

SOL_TL_OPTIONAL_11_CONSTEXPR const T &	value () const &

SOL_TL_OPTIONAL_11_CONSTEXPR T &&	value () &&

SOL_TL_OPTIONAL_11_CONSTEXPR const T &&	value () const &&

template<class U >
constexpr T	value_or (U &&u) const &

template<class U >
SOL_TL_OPTIONAL_11_CONSTEXPR T	value_or (U &&u) &&
	value_or

void	reset () noexcept
	Destroys the stored value if one exists, making the optional empty.

Public Attributes
template<class F >
decltype(optional_map_impl(std::declval< optional & >(), std::declval< F && >())) SOL_TL_OPTIONAL_11_CONSTEXPR	map (F &&f) &
	Carries out some operation on the stored object if there is one. More...

template<class F >
decltype(optional_map_impl(std::declval< optional && >(), std::declval< F && >())) SOL_TL_OPTIONAL_11_CONSTEXPR	map (F &&f) &&

template<class F >
decltype(optional_map_impl(std::declval< const optional & >(), std::declval< F && >())) constexpr	map (F &&f) const &

template<class F >
decltype(optional_map_impl(std::declval< const optional && >(), std::declval< F && >())) constexpr	map (F &&f) const &&

Detailed Description

template<class T>
class sol::optional< T >

An optional object is an object that contains the storage for another object and manages the lifetime of this contained object, if any. The contained object may be initialized after the optional object has been initialized, and may be destroyed before the optional object has been destroyed. The initialization state of the contained object is tracked by the optional object.

Constructor & Destructor Documentation

◆ optional() [1/8]

template<class T>

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

defaultnoexcept

Constructs an optional that does not contain a value. ctor_empty

◆ optional() [2/8]

template<class T>

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

default

Copy constructor

If rhs contains a value, the stored value is direct-initialized with it. Otherwise, the constructed optional is empty.

◆ optional() [3/8]

template<class T>

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

default

Move constructor

If rhs contains a value, the stored value is direct-initialized with it. Otherwise, the constructed optional is empty.

◆ optional() [4/8]

template<class T>

template<class... Args>

constexpr sol::optional< T >::optional	(	detail::enable_if_t< std::is_constructible< T, Args... >::value, in_place_t >	,
		Args &&...	args
	)

inlineexplicit

Constructs the stored value in-place using the given arguments. in_place template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);

◆ optional() [5/8]

template<class T>

template<class U , class... Args>

SOL_TL_OPTIONAL_11_CONSTEXPR sol::optional< T >::optional	(	detail::enable_if_t< std::is_constructible< T, std::initializer_list< U > &, Args &&... >::value, in_place_t >	,
		std::initializer_list< U >	il,
		Args &&...	args
	)

inlineexplicit

in_place template <class U, class... Args>
constexpr explicit optional(in_place_t, std::initializer_list&, Args&&... args);

◆ optional() [6/8]

template<class T>

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

inline

Constructs the stored value with u. template <class u="T"> constexpr optional(U &&u);

◆ optional() [7/8]

template<class T>

template<class U , detail::enable_from_other< T, U, const U &> * = nullptr, detail::enable_if_t< std::is_convertible< const U &, T >::value > * = nullptr>

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

inline

Converting copy constructor. template <class u>=""> optional(const optional &rhs);

◆ optional() [8/8]

template<class T>

template<class U , detail::enable_from_other< T, U, U &&> * = nullptr, detail::enable_if_t< std::is_convertible::value > * = nullptr>

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

inline

Converting move constructor. template <class u>=""> optional(optional &&rhs);

Member Function Documentation

◆ and_then() [1/4]

template<class T>

template<class F >

SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> sol::optional< T >::and_then ( F && f ) &

inline

and_then Carries out some operation which returns an optional on the stored object if there is one. std::invoke(std::forward<F>(f), value()) returns a std::optional for some U.

Returns: Let U be the result of std::invoke(std::forward<F>(f), value()). Returns a std::optional. The return value is empty if *this is empty, otherwise the return value of std::invoke(std::forward<F>(f), value()) is returned. and_then template <class f>="">
constexpr auto and_then(F &&f) &;

◆ and_then() [2/4]

template<class T>

template<class F >

SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> sol::optional< T >::and_then ( F && f ) &&

inline

and_then template <class f>="">
constexpr auto and_then(F &&f) &&;

◆ and_then() [3/4]

template<class T>

template<class F >

constexpr detail::invoke_result_t<F, const T&> sol::optional< T >::and_then ( F && f ) const &

inline

and_then template <class f>="">
constexpr auto and_then(F &&f) const &;

◆ and_then() [4/4]

template<class T>

template<class F >

constexpr detail::invoke_result_t<F, const T&&> sol::optional< T >::and_then ( F && f ) const &&

inline

and_then template <class f>="">
constexpr auto and_then(F &&f) const &&;

◆ conjunction()

template<class T>

template<class U >

constexpr optional<typename std::decay::type> sol::optional< T >::conjunction ( U && u ) const

inline

Returns: u if *this has a value, otherwise an empty optional.

◆ disjunction()

template<class T>

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

inline

Returns: rhs if *this is empty, otherwise the current value. disjunction

◆ emplace() [1/2]

template<class T>

template<class... Args>

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

inline

Constructs the value in-place, destroying the current one if there is one. emplace

◆ emplace() [2/2]

template<class T>

template<class U , class... Args>

detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> sol::optional< T >::emplace	(	std::initializer_list< U >	il,
		Args &&...	args
	)

inline

emplace template <class U, class... Args>
T& emplace(std::initializer_list il, Args &&... args);

◆ has_value()

template<class T>

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

inlinenoexcept

Returns: whether or not the optional has a value has_value

◆ map_or()

template<class T>

template<class F , class U >

U sol::optional< T >::map_or	(	F &&	f,
		U &&	u
	)		&

inline

Maps the stored value with f if there is one, otherwise returns u.

If there is a value stored, then f is called with **this and the value is returned. Otherwise u is returned.

map_or

◆ map_or_else() [1/4]

template<class T>

template<class F , class U >

detail::invoke_result_t<U> sol::optional< T >::map_or_else	(	F &&	f,
		U &&	u
	)		&

inline

Maps the stored value with f if there is one, otherwise calls u and returns the result.

If there is a value stored, then f is called with **this and the value is returned. Otherwise std::forward(u)() is returned.

map_or_else template <class F, class U>
auto map_or_else(F &&f, U &&u) &;

◆ map_or_else() [2/4]

template<class T>

template<class F , class U >

detail::invoke_result_t<U> sol::optional< T >::map_or_else	(	F &&	f,
		U &&	u
	)		&&

inline

map_or_else template <class F, class U>
auto map_or_else(F &&f, U &&u) &&;

◆ map_or_else() [3/4]

template<class T>

template<class F , class U >

detail::invoke_result_t<U> sol::optional< T >::map_or_else	(	F &&	f,
		U &&	u
	)		const &

inline

map_or_else template <class F, class U>
auto map_or_else(F &&f, U &&u) const &;

◆ map_or_else() [4/4]

template<class T>

template<class F , class U >

detail::invoke_result_t<U> sol::optional< T >::map_or_else	(	F &&	f,
		U &&	u
	)		const &&

inline

map_or_else template <class F, class U>
auto map_or_else(F &&f, U &&u) const &&;

◆ operator*() [1/2]

template<class T>

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

inline

Returns: the stored value a value is stored deref constexpr T &operator*();

◆ operator*() [2/2]

template<class T>

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

inline

deref constexpr const T &operator*() const;

◆ operator->() [1/2]

template<class T>

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

inline

Returns: a pointer to the stored value a value is stored pointer constexpr const T *operator->() const;

◆ operator->() [2/2]

template<class T>

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

inline

pointer constexpr T *operator->();

◆ operator=() [1/6]

template<class T>

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

inlinenoexcept

Assignment to empty.

Destroys the current value if there is one.

◆ operator=() [2/6]

template<class T>

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

default

Copy assignment.

Copies the value from rhs if there is one. Otherwise resets the stored value in *this.

◆ operator=() [3/6]

template<class T>

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

default

Move assignment.

Moves the value from rhs if there is one. Otherwise resets the stored value in *this.

◆ operator=() [4/6]

template<class T>

template<class U = T, detail::enable_assign_forward< T, U > * = nullptr>

optional& sol::optional< T >::operator= ( U && u )

inline

Assigns the stored value from u, destroying the old value if there was one. optional &operator=(U &&u);

◆ operator=() [5/6]

template<class T>

template<class U , detail::enable_assign_from_other< T, U, const U &> * = nullptr>

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

inline

Converting copy assignment operator.

Copies the value from rhs if there is one. Otherwise resets the stored value in *this. optional &operator=(const optional & rhs);

◆ operator=() [6/6]

template<class T>

template<class U , detail::enable_assign_from_other< T, U, U > * = nullptr>

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

inline

Converting move assignment operator.

Moves the value from rhs if there is one. Otherwise resets the stored value in *this. optional &operator=(optional && rhs);

◆ or_else() [1/3]

template<class T>

template<class F , detail::enable_if_ret_void< F > * = nullptr>

optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR sol::optional< T >::or_else ( F && f ) &

inline

Calls f if the optional is empty std::invoke_result_t<F> must be void or convertible to optional<T>. If *this has a value, returns *this. Otherwise, if f returns void, calls std::forward<F>(f) and returns std::nullopt. Otherwise, returns std::forward<F>(f)().

or_else template <class f>=""> optional<T> or_else (F &&f) &;

◆ or_else() [2/3]

template<class T>

template<class F , detail::enable_if_ret_void< F > * = nullptr>

optional<T> sol::optional< T >::or_else ( F && f ) &&

inline

or_else template <class f>=""> optional<T> or_else (F &&f) &&;

◆ or_else() [3/3]

template<class T>

template<class F , detail::enable_if_ret_void< F > * = nullptr>

optional<T> sol::optional< T >::or_else ( F && f ) const &

inline

or_else template <class f>=""> optional<T> or_else (F &&f) const &;

◆ swap()

template<class T>

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

inlinenoexcept

Swaps this optional with the other.

If neither optionals have a value, nothing happens. If both have a value, the values are swapped. If one has a value, it is moved to the other and the movee is left valueless.

◆ take()

template<class T>

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

inline

Takes the value out of the optional, leaving it empty take

◆ value() [1/2]

template<class T>

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

inline

Returns: the contained value if there is one, otherwise throws [bad_optional_access] value constexpr T &value();

◆ value() [2/2]

template<class T>

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

inline

value constexpr const T &value() const;

◆ value_or()

template<class T>

template<class U >

constexpr T sol::optional< T >::value_or ( U && u ) const &

inline

Returns: the stored value if there is one, otherwise returns u value_or

Member Data Documentation

◆ map [1/4]

template<class T>

template<class F >

decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) SOL_TL_OPTIONAL_11_CONSTEXPR sol::optional< T >::map(F &&f) &

inline

Carries out some operation on the stored object if there is one.

Returns: Let U be the result of std::invoke(std::forward<F>(f), value()). Returns a std::optional. The return value is empty if *this is empty, otherwise an optional is constructed from the return value of std::invoke(std::forward<F>(f), value()) and is returned.

map template <class f>=""> auto map(F &&f) &;

◆ map [2/4]

template<class T>

template<class F >

decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) SOL_TL_OPTIONAL_11_CONSTEXPR sol::optional< T >::map(F &&f) &&

inline

map template <class f>=""> auto map(F &&f) &&;

◆ map [3/4]

template<class T>

template<class F >

decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) constexpr sol::optional< T >::map(F &&f) const &

inline

map template <class f>=""> auto map(F &&f) const&;

◆ map [4/4]

template<class T>

template<class F >

decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) constexpr sol::optional< T >::map(F &&f) const &&

inline

map template <class f>=""> auto map(F &&f) const&&;

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

3rd/sol.hpp

Public Types

Public Member Functions

Public Attributes

Detailed Description

template<class T> class sol::optional< T >

Constructor & Destructor Documentation

◆ optional() [1/8]

◆ optional() [2/8]

◆ optional() [3/8]

◆ optional() [4/8]

◆ optional() [5/8]

◆ optional() [6/8]

◆ optional() [7/8]

◆ optional() [8/8]

Member Function Documentation

◆ and_then() [1/4]

◆ and_then() [2/4]

◆ and_then() [3/4]

◆ and_then() [4/4]

◆ conjunction()

◆ disjunction()

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ has_value()

◆ map_or()

◆ map_or_else() [1/4]

◆ map_or_else() [2/4]

◆ map_or_else() [3/4]

◆ map_or_else() [4/4]

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator->() [1/2]

◆ operator->() [2/2]

◆ operator=() [1/6]

◆ operator=() [2/6]

◆ operator=() [3/6]

◆ operator=() [4/6]

◆ operator=() [5/6]

◆ operator=() [6/6]

◆ or_else() [1/3]

◆ or_else() [2/3]

◆ or_else() [3/3]

◆ swap()

◆ take()

◆ value() [1/2]

◆ value() [2/2]

◆ value_or()

Member Data Documentation

◆ map [1/4]

◆ map [2/4]

◆ map [3/4]

◆ map [4/4]

template<class T>
class sol::optional< T >