#include <sol.hpp>

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

constexpr	optional (nullopt_t) noexcept
	ctor_empty

SOL_TL_OPTIONAL_11_CONSTEXPR	optional (const optional &rhs) noexcept=default

SOL_TL_OPTIONAL_11_CONSTEXPR	optional (optional &&rhs)=default

template<class U = T, detail::enable_if_t<!detail::is_optional< detail::decay_t< U >>::value > * = nullptr>
constexpr	optional (U &&u)

template<class U >
constexpr	optional (const optional< U > &rhs)

	~optional ()=default
	No-op.

optional &	operator= (nullopt_t) noexcept

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

template<class U = T, detail::enable_if_t<!detail::is_optional< detail::decay_t< U >>::value > * = nullptr>
optional &	operator= (U &&u)

template<class U >
optional &	operator= (const optional< U > &rhs)

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

void	swap (optional &rhs) noexcept

constexpr const T *	operator-> () const

SOL_TL_OPTIONAL_11_CONSTEXPR T *	operator-> ()

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

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

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

Public Attributes
template<class F >
decltype(detail::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(detail::optional_map_impl(std::declval< optional && >(), std::declval< F && >())) SOL_TL_OPTIONAL_11_CONSTEXPR	map (F &&f) &&

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

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

Detailed Description

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

Specialization for when T is a reference. optional<T&> acts similarly to a T*, but provides more operations and shows intent more clearly.

Examples:

int i = 42;
sol::optional<int&> o = i;
*o == 42; //true
i = 12;
*o = 12; //true
&*o == &i; //true

Assignment has rebind semantics rather than assign-through semantics:

int j = 8;
o = j;
&*o == &j; //true

Constructor & Destructor Documentation

◆ optional() [1/4]

template<class T >

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

inlinenoexcept

Constructs an optional that does not contain a value. ctor_empty

◆ optional() [2/4]

template<class T >

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

defaultnoexcept

Copy constructor

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

◆ optional() [3/4]

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/4]

template<class T >

template<class U = T, detail::enable_if_t<!detail::is_optional< detail::decay_t>::value > * = nullptr>

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

inline

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

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()

template<class T >

template<class... Args>

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

inlinenoexcept

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

emplace

◆ 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/4]

template<class T >

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

inlinenoexcept

Assignment to empty.

Destroys the current value if there is one.

◆ operator=() [2/4]

template<class T >

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

default

Copy assignment.

Rebinds this optional to the referee of rhs if there is one. Otherwise resets the stored value in *this.

◆ operator=() [3/4]

template<class T >

template<class U = T, detail::enable_if_t<!detail::is_optional< detail::decay_t>::value > * = nullptr>

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

inline

Rebinds this optional to u.

U must be an lvalue reference. optional &operator=(U &&u);

◆ operator=() [4/4]

template<class T >

template<class U >

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

inline

Converting copy assignment operator.

Rebinds this optional to the referee of rhs if there is one. Otherwise resets the stored value in *this.

◆ 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 synopsis 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(detail::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(detail::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(detail::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(detail::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/4]

◆ optional() [2/4]

◆ optional() [3/4]

◆ optional() [4/4]

Member Function Documentation

◆ and_then() [1/4]

◆ and_then() [2/4]

◆ and_then() [3/4]

◆ and_then() [4/4]

◆ conjunction()

◆ disjunction()

◆ emplace()

◆ 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/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ 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 & >