mirror of
https://github.com/TartanLlama/optional.git
synced 2025-07-30 18:07:15 +02:00
Docs
This commit is contained in:
644
docs/index.md
644
docs/index.md
@ -1,309 +1,84 @@
|
||||
# Header file `optional.hpp`<a id="optional.hpp"></a>
|
||||
|
||||
<pre><code class="language-cpp">#define <a href='doc_optional.md#optional.hpp'>TL_OPTIONAL_11_CONSTEXPR</a>
|
||||
|
||||
#define <a href='doc_optional.md#optional.hpp'>TL_OPTIONAL_MSVC_2015_CONSTEXPR</a>
|
||||
|
||||
namespace <a href='doc_optional.md#optional.hpp'>tl</a>
|
||||
<pre><code class="language-cpp">namespace <a href='doc_optional.md#optional.hpp'>tl</a>
|
||||
{
|
||||
class <a href='doc_optional.md#optional.hpp'>monostate</a>;
|
||||
class <a href='doc_optional.md#tl::monostate'>monostate</a>;
|
||||
|
||||
namespace <a href='doc_optional.md#optional.hpp'>detail</a>
|
||||
{
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_cv_t</a> = typename std::remove_cv<T>::type;
|
||||
struct <a href='doc_optional.md#tl::in_place_t'>in_place_t</a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_const_t</a> = typename std::remove_const<T>::type;
|
||||
constexpr <a href='doc_optional.md#tl::in_place_t'>in_place_t{}</a> <a href='doc_optional.md#tl::in_place'>in_place</a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_volatile_t</a> = typename std::remove_volatile<T>::type;
|
||||
struct <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_cv_t</a> = typename std::add_cv<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_const_t</a> = typename std::add_const<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_volatile_t</a> = typename std::add_volatile<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_reference_t</a> = typename std::remove_reference<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_lvalue_reference_t</a> = typename std::add_lvalue_reference<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_rvalue_reference_t</a> = typename std::add_rvalue_reference<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_pointer_t</a> = typename std::remove_pointer<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>add_pointer_t</a> = typename std::add_pointer<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>make_signed_t</a> = typename std::make_signed<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>make_unsigned_t</a> = typename std::make_unsigned<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_extent_t</a> = typename std::remove_extent<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>remove_all_extents_t</a> = typename std::remove_all_extents<T>::type;
|
||||
|
||||
template <<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> N, <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> A = N>
|
||||
using <a href='doc_optional.md#optional.hpp'>aligned_storage_t</a> = typename std::aligned_storage<N, A>::type;
|
||||
|
||||
template <<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> N, class ... Ts>
|
||||
using <a href='doc_optional.md#optional.hpp'>aligned_union_t</a> = typename std::aligned_union<N, Ts...>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>decay_t</a> = typename std::decay<T>::type;
|
||||
|
||||
template <bool E, class T = void>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_if_t</a> = typename std::enable_if<E, T>::type;
|
||||
|
||||
template <bool B, class T, class F>
|
||||
using <a href='doc_optional.md#optional.hpp'>conditional_t</a> = typename std::conditional<B, T, F>::type;
|
||||
|
||||
template <class ... Ts>
|
||||
using <a href='doc_optional.md#optional.hpp'>common_type_t</a> = typename std::common_type<Ts...>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>underlying_type_t</a> = typename std::underlying_type<T>::type;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>result_of_t</a> = typename std::result_of<T>::type;
|
||||
|
||||
template <class>
|
||||
struct <a href='doc_optional.md#optional.hpp'>conjunction</a>;
|
||||
|
||||
template <class B>
|
||||
struct <a href='doc_optional.md#optional.hpp'>conjunction<B></a>;
|
||||
|
||||
template <class B, class ... Bs>
|
||||
struct <a href='doc_optional.md#optional.hpp'>conjunction<B, Bs...></a>;
|
||||
|
||||
template <class>
|
||||
struct <a href='doc_optional.md#optional.hpp'>voider</a>;
|
||||
|
||||
template <class ... Ts>
|
||||
using <a href='doc_optional.md#optional.hpp'>void_t</a> = typename voider<Ts...>::type;
|
||||
|
||||
template <class T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_optional_impl</a>;
|
||||
|
||||
template <class T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_optional_impl<optional<T>></a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>is_optional</a> = <a href='doc_optional.md#optional.hpp'>is_optional_impl<decay_t<T>></a>;
|
||||
|
||||
template <typename Fn, typename ... Args, typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>{}>, int=0>
|
||||
constexpr decltype(std::mem_fn(f)(std::forward<Args>(args)...)) <a href='doc_optional.md#optional.hpp'>invoke</a>(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)));
|
||||
|
||||
template <typename Fn, typename ... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>{}>>
|
||||
constexpr decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) <a href='doc_optional.md#optional.hpp'>invoke</a>(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)));
|
||||
|
||||
template <class F, class ... Us>
|
||||
struct <a href='doc_optional.md#optional.hpp'>invoke_result_impl<F, decltype(invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...></a>;
|
||||
|
||||
template <class F, class ... Us>
|
||||
using <a href='doc_optional.md#optional.hpp'>invoke_result</a> = invoke_result_impl<F, void, Us...>;
|
||||
|
||||
template <class F, class ... Us>
|
||||
using <a href='doc_optional.md#optional.hpp'>invoke_result_t</a> = typename invoke_result<F, Us...>::type;
|
||||
|
||||
template <class U>
|
||||
using <a href='doc_optional.md#optional.hpp'>fixup_void</a> = <a href='doc_optional.md#optional.hpp'>conditional_t<std::is_void<U>::value, monostate, U></a>;
|
||||
|
||||
template <class F, class ... U>
|
||||
struct <a href='doc_optional.md#optional.hpp'>get_invoke_optional_ret</a>;
|
||||
|
||||
template <class F, class ... U>
|
||||
using <a href='doc_optional.md#optional.hpp'>get_invoke_ret</a> = typename conditional_t<is_optional<F>::value, get_invoke_optional_ret<F, U...>, invoke_result<F, U...>>::type;
|
||||
|
||||
template <class F, class U>
|
||||
using <a href='doc_optional.md#optional.hpp'>get_map_return</a> = <a href='doc_optional.md#tl::optional-T-'>optional<fixup_void<get_invoke_ret<F, U>>></a>;
|
||||
|
||||
template <class F, class ... U>
|
||||
using <a href='doc_optional.md#optional.hpp'>returns_void</a> = <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::is_void%3cget_invoke_ret%3cF,U...%3e%3e'>std::is_void<get_invoke_ret<F, U...>></a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>disable_if_optional</a> = <a href='doc_optional.md#optional.hpp'>enable_if_t<!is_optional<T>::value></a>;
|
||||
|
||||
template <class T>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_if_optional</a> = <a href='doc_optional.md#optional.hpp'>enable_if_t<is_optional<T>::value></a>;
|
||||
|
||||
template <class T, class ... U>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_if_ret_void</a> = <a href='doc_optional.md#optional.hpp'>enable_if_t<returns_void<T&&, U...>::value></a>;
|
||||
|
||||
template <class T, class ... U>
|
||||
using <a href='doc_optional.md#optional.hpp'>disable_if_ret_void</a> = <a href='doc_optional.md#optional.hpp'>enable_if_t<!returns_void<T&&, U...>::value></a>;
|
||||
}
|
||||
|
||||
struct <a href='doc_optional.md#optional.hpp'>in_place_t</a>;
|
||||
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>in_place_t{}</a> <a href='doc_optional.md#optional.hpp'>in_place</a>;
|
||||
|
||||
namespace <a href='doc_optional.md#optional.hpp'>detail</a>
|
||||
{
|
||||
template <class T, class U>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_forward_value</a> = <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, U&&>::value&&!std::is_same<detail::decay_t<U>, in_place_t>::value&&!std::is_same<optional<T>, detail::decay_t<U>>::value></a>;
|
||||
|
||||
template <class T, class U, class Other>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_from_other</a> = <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, Other>::value&&!std::is_constructible<T, optional<U>&>::value&&!std::is_constructible<T, optional<U>&&>::value&&!std::is_constructible<T, const optional<U>&>::value&&!std::is_constructible<T, const optional<U>&&>::value&&!std::is_convertible<optional<U>&, T>::value&&!std::is_convertible<optional<U>&&, T>::value&&!std::is_convertible<const optional<U>&, T>::value&&!std::is_convertible<const optional<U>&&, T>::value></a>;
|
||||
|
||||
template <class T, class U>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_assign_forward</a> = <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value&&!detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value&&std::is_constructible<T, U>::value&&std::is_assignable<T&, U>::value></a>;
|
||||
|
||||
template <class T, class U, class Other>
|
||||
using <a href='doc_optional.md#optional.hpp'>enable_assign_from_other</a> = <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, Other>::value&&std::is_assignable<T&, Other>::value&&!std::is_constructible<T, optional<U>&>::value&&!std::is_constructible<T, optional<U>&&>::value&&!std::is_constructible<T, const optional<U>&>::value&&!std::is_constructible<T, const optional<U>&&>::value&&!std::is_convertible<optional<U>&, T>::value&&!std::is_convertible<optional<U>&&, T>::value&&!std::is_convertible<const optional<U>&, T>::value&&!std::is_convertible<const optional<U>&&, T>::value&&!std::is_assignable<T&, optional<U>&>::value&&!std::is_assignable<T&, optional<U>&&>::value&&!std::is_assignable<T&, const optional<U>&>::value&&!std::is_assignable<T&, const optional<U>&&>::value></a>;
|
||||
|
||||
namespace <a href='doc_optional.md#optional.hpp'>swap_adl_tests</a>
|
||||
{
|
||||
struct <a href='doc_optional.md#optional.hpp'>tag</a>;
|
||||
|
||||
template <class T>
|
||||
<a href='doc_optional.md#optional.hpp'>tag</a> <a href='doc_optional.md#optional.hpp'>swap</a>(T&, T&);
|
||||
|
||||
template <class T, <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> N>
|
||||
<a href='doc_optional.md#optional.hpp'>tag</a> <a href='doc_optional.md#optional.hpp'>swap</a>(T(&)[N] a, T(&)[N] b);
|
||||
|
||||
template <class, class>
|
||||
<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::false_type'>std::false_type</a> <a href='doc_optional.md#optional.hpp'>can_swap</a>(...) noexcept(false);
|
||||
|
||||
template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
|
||||
)>std::true_type <a href='doc_optional.md#optional.hpp'>can_swap</a>(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
|
||||
|
||||
template <class, class>
|
||||
<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::false_type'>std::false_type</a> <a href='doc_optional.md#optional.hpp'>uses_std</a>(...);
|
||||
|
||||
template <class T, class U>
|
||||
<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::is_same%3cdecltype(swap(std::declval%3cT&%3e(),std::declval%3cU&%3e())),tag%3e'>std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag></a> <a href='doc_optional.md#optional.hpp'>uses_std</a>(int);
|
||||
|
||||
template <class T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_std_swap_noexcept</a>;
|
||||
|
||||
template <class T, <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> N>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_std_swap_noexcept<T[N]></a>;
|
||||
|
||||
template <class T, class U>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_adl_swap_noexcept</a>;
|
||||
}
|
||||
|
||||
template <class T, class U = T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_swappable</a>;
|
||||
|
||||
template <class T, <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::size_t'>std::size_t</a> N>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_swappable<T[N], T[N]></a>;
|
||||
|
||||
template <class T, class U = T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>is_nothrow_swappable</a>;
|
||||
}
|
||||
|
||||
struct <a href='doc_optional.md#optional.hpp'>nullopt_t</a>;
|
||||
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>nullopt_t{nullopt_t::do_not_use{}, nullopt_t::do_not_use{}}</a> <a href='doc_optional.md#optional.hpp'>nullopt</a>;
|
||||
static constexpr nullopt_t nullopt;
|
||||
|
||||
class <a href='doc_optional.md#optional.hpp'>bad_optional_access</a>;
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constoptional-U-&)'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator==</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator!=</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator<</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator<=</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator></a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,tl::nullopt_t)'>operator>=</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator==</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator!=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator<</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator<=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator></a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#tl::operator==(constoptional-T-&,constU&)'>operator>=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator==</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator!=</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<=</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator></a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
|
||||
template <class T>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator>=</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator==</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator==</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator!=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator!=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator<=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator></a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator></a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator>=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
template <class T, class U>
|
||||
constexpr bool <a href='doc_optional.md#optional.hpp'>operator>=</a>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
template <class T, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_move_constructible<T>::value>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<detail::is_swappable<T>::value>*=nullptr</a>>
|
||||
void <a href='doc_optional.md#optional.hpp'>swap</a>(<a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept(noexcept(lhs.swap(rhs)));
|
||||
void swap(optional<T> &lhs, optional<T> &rhs);
|
||||
|
||||
template <class T>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional<detail::decay_t<T>></a> <a href='doc_optional.md#optional.hpp'>make_optional</a>(T&& v);
|
||||
@ -321,20 +96,163 @@ namespace <a href='doc_optional.md#optional.hpp'>std</a>
|
||||
|
||||
namespace <a href='doc_optional.md#optional.hpp'>tl</a>
|
||||
{
|
||||
namespace <a href='doc_optional.md#optional.hpp'>detail</a>
|
||||
{
|
||||
template <class T, bool=::std::is_trivially_destructible<T>::value>
|
||||
struct <a href='doc_optional.md#optional.hpp'>optional_storage_base</a>;
|
||||
|
||||
template <class T>
|
||||
struct <a href='doc_optional.md#optional.hpp'>optional_storage_base<T, true></a>;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
class <a href='doc_optional.md#tl::optional-T-'>optional</a>;
|
||||
}</code></pre>
|
||||
|
||||
-----
|
||||
## Class `tl::monostate`<a id="tl::monostate"></a>
|
||||
|
||||
<pre><code class="language-cpp">class monostate
|
||||
{
|
||||
};</code></pre>
|
||||
|
||||
Represents an optional with no data; essentially a bool
|
||||
|
||||
## Struct `tl::in_place_t`<a id="tl::in_place_t"></a>
|
||||
|
||||
<pre><code class="language-cpp">struct in_place_t
|
||||
{
|
||||
<a href='doc_optional.md#tl::in_place_t'>in_place_t</a>() = default;
|
||||
};</code></pre>
|
||||
|
||||
A tag type to tell optional to construct its value in-place
|
||||
|
||||
## Variable `tl::in_place`<a id="tl::in_place"></a>
|
||||
|
||||
<pre><code class="language-cpp">constexpr <a href='doc_optional.md#tl::in_place_t'>in_place_t{}</a> in_place;</code></pre>
|
||||
|
||||
A tag to tell optional to construct its value in-place
|
||||
|
||||
## Struct `tl::nullopt_t`<a id="tl::nullopt_t"></a>
|
||||
|
||||
<pre><code class="language-cpp">struct nullopt_t
|
||||
{
|
||||
struct <a href='doc_optional.md#tl::nullopt_t'>do_not_use</a>;
|
||||
|
||||
constexpr <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>(<a href='doc_optional.md#tl::nullopt_t'>do_not_use</a>, <a href='doc_optional.md#tl::nullopt_t'>do_not_use</a>) noexcept;
|
||||
};</code></pre>
|
||||
|
||||
A tag type to represent an empty optional
|
||||
|
||||
## Variable `tl::nullopt`<a id="tl::nullopt"></a>
|
||||
|
||||
<pre><code class="language-cpp">static constexpr nullopt_t nullopt;</code></pre>
|
||||
|
||||
Represents an empty optional
|
||||
|
||||
*Examples*:
|
||||
|
||||
tl::optional<int> a = tl::nullopt;
|
||||
void foo (tl::optional<int>);
|
||||
foo(tl::nullopt); //pass an empty optional
|
||||
|
||||
## Comparison operator `tl::operator==`<a id="tl::operator==(constoptional-T-&,constoptional-U-&)"></a>
|
||||
|
||||
<pre><code class="language-cpp">(1) template <class T, class U>
|
||||
constexpr bool operator==(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
(2) template <class T, class U>
|
||||
constexpr bool operator!=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
(3) template <class T, class U>
|
||||
constexpr bool operator<(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
(4) template <class T, class U>
|
||||
constexpr bool operator>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
(5) template <class T, class U>
|
||||
constexpr bool operator<=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
(6) template <class T, class U>
|
||||
constexpr bool operator>=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);</code></pre>
|
||||
|
||||
Compares two optional objects
|
||||
|
||||
If both optionals contain a value, they are compared with `T`s relational operators. Otherwise `lhs` and `rhs` are equal only if they are both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs` is not.
|
||||
|
||||
## Comparison operator `tl::operator==`<a id="tl::operator==(constoptional-T-&,tl::nullopt_t)"></a>
|
||||
|
||||
<pre><code class="language-cpp">(1) template <class T>
|
||||
constexpr bool operator==(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(2) template <class T>
|
||||
constexpr bool operator==(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
(3) template <class T>
|
||||
constexpr bool operator!=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(4) template <class T>
|
||||
constexpr bool operator!=(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
(5) template <class T>
|
||||
constexpr bool operator<(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(6) template <class T>
|
||||
constexpr bool operator<(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;
|
||||
|
||||
(7) template <class T>
|
||||
constexpr bool operator<=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(8) template <class T>
|
||||
constexpr bool operator<=(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
|
||||
(9) template <class T>
|
||||
constexpr bool operator>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(10) template <class T>
|
||||
constexpr bool operator>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&) noexcept;
|
||||
|
||||
(11) template <class T>
|
||||
constexpr bool operator>=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>&, <a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
(12) template <class T>
|
||||
constexpr bool operator>=(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs) noexcept;</code></pre>
|
||||
|
||||
Compares an optional to a `nullopt`
|
||||
|
||||
Equivalent to comparing the optional to an empty optional
|
||||
|
||||
## Comparison operator `tl::operator==`<a id="tl::operator==(constoptional-T-&,constU&)"></a>
|
||||
|
||||
<pre><code class="language-cpp">(1) template <class T, class U>
|
||||
constexpr bool operator==(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(2) template <class T, class U>
|
||||
constexpr bool operator==(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
(3) template <class T, class U>
|
||||
constexpr bool operator!=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(4) template <class T, class U>
|
||||
constexpr bool operator!=(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
(5) template <class T, class U>
|
||||
constexpr bool operator<(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(6) template <class T, class U>
|
||||
constexpr bool operator<(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
(7) template <class T, class U>
|
||||
constexpr bool operator<=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(8) template <class T, class U>
|
||||
constexpr bool operator<=(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
(9) template <class T, class U>
|
||||
constexpr bool operator>(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(10) template <class T, class U>
|
||||
constexpr bool operator>(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);
|
||||
|
||||
(11) template <class T, class U>
|
||||
constexpr bool operator>=(const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& lhs, const U& rhs);
|
||||
|
||||
(12) template <class T, class U>
|
||||
constexpr bool operator>=(const U& lhs, const <a href='doc_optional.md#tl::optional-T-'>optional<T></a>& rhs);</code></pre>
|
||||
|
||||
Compares the optional with a value.
|
||||
|
||||
If the optional has a value, it is compared with the other value using `T`s relational operators. Otherwise, the optional is considered less than the value.
|
||||
|
||||
-----
|
||||
|
||||
@ -346,60 +264,60 @@ class optional
|
||||
public:
|
||||
using <a href='doc_optional.md#tl::optional-T-'>value_type</a> = T;
|
||||
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>() noexcept = default;
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-::optional()'>optional</a>() noexcept = default;
|
||||
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-::optional(tl::nullopt_t)'>optional</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(const <a href='doc_optional.md#tl::optional-T-'>optional</a>& rhs);
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-::optional(constoptional-T-&)'>optional</a>(const <a href='doc_optional.md#tl::optional-T-'>optional</a>& rhs);
|
||||
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#tl::optional-T-'>optional</a>&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value);
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-::optional(optional-T-&&)'>optional</a>(<a href='doc_optional.md#tl::optional-T-'>optional</a>&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value);
|
||||
|
||||
template <class ... Args>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t></a>, Args&&... args);
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>('hidden', Args&&... args);
|
||||
|
||||
template <class U, class ... Args>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t></a>, <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::initializer_list%3cU%3e'>std::initializer_list<U></a> il, Args&&... args);
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>('hidden', <a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::initializer_list%3cU%3e'>std::initializer_list<U></a> il, Args&&... args);
|
||||
|
||||
template <class U = T, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_convertible<U&&, T>::value>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_forward_value<T, U>*=nullptr</a>>
|
||||
template <class U = T, 'hidden', 'hidden'>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(U&& u);
|
||||
|
||||
template <class U = T, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<!std::is_convertible<U&&, T>::value>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_forward_value<T, U>*=nullptr</a>>
|
||||
template <class U = T, 'hidden', 'hidden'>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional</a>(U&& u);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_from_other<T, U, const U&>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_convertible<const U&, T>::value>*=nullptr</a>>
|
||||
template <class U, 'hidden', 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_from_other<T, U, const U&>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<!std::is_convertible<const U&, T>::value>*=nullptr</a>>
|
||||
template <class U, 'hidden', 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_from_other<T, U, U&&>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_convertible<U&&, T>::value>*=nullptr</a>>
|
||||
template <class U, 'hidden', 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#tl::optional-T-'>optional<U></a>&& rhs);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_from_other<T, U, U&&>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_t<!std::is_convertible<U&&, T>::value>*=nullptr</a>>
|
||||
template <class U, 'hidden', 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>(<a href='doc_optional.md#tl::optional-T-'>optional<U></a>&& rhs);
|
||||
|
||||
<a href='doc_optional.md#tl::optional-T-'>~optional</a>() = default;
|
||||
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(<a href='doc_optional.md#optional.hpp'>nullopt_t</a>) noexcept;
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;
|
||||
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional</a>& rhs);
|
||||
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(<a href='doc_optional.md#tl::optional-T-'>optional</a>&& rhs) noexcept(std::is_nothrow_move_assignable<T>::value&&std::is_nothrow_move_constructible<T>::value);
|
||||
|
||||
template <class U = T, <a href='doc_optional.md#optional.hpp'>detail::enable_assign_forward<T, U>*=nullptr</a>>
|
||||
template <class U = T, 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(U&& u);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_assign_from_other<T, U, const U&>*=nullptr</a>>
|
||||
template <class U, 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(const <a href='doc_optional.md#tl::optional-T-'>optional<U></a>& rhs);
|
||||
|
||||
template <class U, <a href='doc_optional.md#optional.hpp'>detail::enable_assign_from_other<T, U, U>*=nullptr</a>>
|
||||
template <class U, 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional</a>& <a href='doc_optional.md#tl::optional-T-'>operator=</a>(<a href='doc_optional.md#tl::optional-T-'>optional<U></a>&& rhs);
|
||||
|
||||
template <class ... Args>
|
||||
T& <a href='doc_optional.md#tl::optional-T-'>emplace</a>(Args&&... args);
|
||||
|
||||
template <class U, class ... Args>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&></a> <a href='doc_optional.md#tl::optional-T-'>emplace</a>(<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::initializer_list%3cU%3e'>std::initializer_list<U></a> il, Args&&... args);
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-'>emplace</a>(<a href='http://en.cppreference.com/mwiki/index.php?title=Special%3ASearch&search=std::initializer_list%3cU%3e'>std::initializer_list<U></a> il, Args&&... args);
|
||||
|
||||
void <a href='doc_optional.md#tl::optional-T-'>swap</a>(<a href='doc_optional.md#tl::optional-T-'>optional</a>& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&&detail::is_nothrow_swappable<T>::value);
|
||||
|
||||
@ -436,73 +354,73 @@ public:
|
||||
void <a href='doc_optional.md#tl::optional-T-'>reset</a>() noexcept;
|
||||
|
||||
template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&'>and_then</a>(F&& f) &;
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&'>and_then</a>(F&& f) &;
|
||||
template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&'>and_then</a>(F&& f) const &;
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&'>and_then</a>(F&& f) const &;
|
||||
|
||||
template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&&'>and_then</a>(F&& f) &&;
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&&'>and_then</a>(F&& f) &&;
|
||||
template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&&'>and_then</a>(F&& f) const &&;
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::and_then(F&&)&&'>and_then</a>(F&& f) const &&;
|
||||
|
||||
template <class F> auto map(F &&f) &;
|
||||
template <class F> auto map(F &&f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F, T&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) &;
|
||||
|
||||
template <class F> auto map(F &&f) &;
|
||||
template <class F> auto map(F &&f) const &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T&&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F, T&&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T&&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T const&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T const&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F, T const&>*=nullptr</a>>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T const&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T const&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T const&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&'>map</a>(F&& f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T const&&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T const&&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F, T const&&>*=nullptr</a>>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T const&&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
constexpr 'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::enable_if_optional<F>*=nullptr</a>, <a href='doc_optional.md#optional.hpp'>detail::enable_if_ret_void<F, T const&&>*=nullptr</a>>
|
||||
<a href='doc_optional.md#optional.hpp'>detail::get_map_return<F, T&></a> <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
template <class F, 'hidden', 'hidden'>
|
||||
'hidden' <a href='doc_optional.md#tl::optional-T-::map(F&&)&&'>map</a>(F&& f) const &&;
|
||||
|
||||
template <class F> optional<T> or_else (F &&f) &;
|
||||
template <class F> optional<T> or_else (F &&f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F>*=nullptr</a>>
|
||||
template <class F, 'hidden'>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional<T></a> <a href='doc_optional.md#tl::optional-T-::or_else(F&&)&'>or_else</a>(F&& f) &;
|
||||
|
||||
template <class F> optional<T> or_else (F &&f) &&;
|
||||
template <class F> optional<T> or_else (F &&f) const &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F>*=nullptr</a>>
|
||||
template <class F, 'hidden'>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional<T></a> <a href='doc_optional.md#tl::optional-T-::or_else(F&&)&&'>or_else</a>(F&& f) &&;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F>*=nullptr</a>>
|
||||
template <class F, 'hidden'>
|
||||
constexpr <a href='doc_optional.md#tl::optional-T-'>optional<T></a> <a href='doc_optional.md#tl::optional-T-::or_else(F&&)&'>or_else</a>(F&& f) const &;
|
||||
|
||||
template <class F, <a href='doc_optional.md#optional.hpp'>detail::disable_if_ret_void<F>*=nullptr</a>>
|
||||
template <class F, 'hidden'>
|
||||
<a href='doc_optional.md#tl::optional-T-'>optional<T></a> <a href='doc_optional.md#tl::optional-T-::or_else(F&&)&&'>or_else</a>(F&& f) const &&;
|
||||
|
||||
template <class F, class U>
|
||||
@ -532,13 +450,41 @@ public:
|
||||
|
||||
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.
|
||||
|
||||
### Default constructor `tl::optional::optional`<a id="tl::optional-T-::optional()"></a>
|
||||
|
||||
<pre><code class="language-cpp">constexpr optional() noexcept = default;</code></pre>
|
||||
|
||||
Constructs an optional that does not contain a value.
|
||||
|
||||
### Constructor `tl::optional::optional`<a id="tl::optional-T-::optional(tl::nullopt_t)"></a>
|
||||
|
||||
<pre><code class="language-cpp">constexpr optional(<a href='doc_optional.md#tl::nullopt_t'>nullopt_t</a>) noexcept;</code></pre>
|
||||
|
||||
Constructs an optional that does not contain a value.
|
||||
|
||||
### Constructor `tl::optional::optional`<a id="tl::optional-T-::optional(constoptional-T-&)"></a>
|
||||
|
||||
<pre><code class="language-cpp">constexpr optional(const <a href='doc_optional.md#tl::optional-T-'>optional</a>& rhs);</code></pre>
|
||||
|
||||
Copy constructor
|
||||
|
||||
If `rhs` contains a value, the stored value is direct-initialized with it. Otherwise, the constructed optional is empty.
|
||||
|
||||
### Constructor `tl::optional::optional`<a id="tl::optional-T-::optional(optional-T-&&)"></a>
|
||||
|
||||
<pre><code class="language-cpp">constexpr optional(<a href='doc_optional.md#tl::optional-T-'>optional</a>&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value);</code></pre>
|
||||
|
||||
Move constructor
|
||||
|
||||
If `rhs` contains a value, the stored value is direct-initialized with it. Otherwise, the constructed optional is empty.
|
||||
|
||||
### Function template `tl::optional::and_then`<a id="tl::optional-T-::and_then(F&&)&"></a>
|
||||
|
||||
<pre><code class="language-cpp">(1) template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> and_then(F&& f) &;
|
||||
constexpr 'hidden' and_then(F&& f) &;
|
||||
|
||||
(2) template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> and_then(F&& f) const &;</code></pre>
|
||||
constexpr 'hidden' and_then(F&& f) const &;</code></pre>
|
||||
|
||||
Carries out some operation which returns an optional on the stored object if there is one.
|
||||
|
||||
@ -549,10 +495,10 @@ Carries out some operation which returns an optional on the stored object if the
|
||||
### Function template `tl::optional::and_then`<a id="tl::optional-T-::and_then(F&&)&&"></a>
|
||||
|
||||
<pre><code class="language-cpp">(1) template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> and_then(F&& f) &&;
|
||||
constexpr 'hidden' and_then(F&& f) &&;
|
||||
|
||||
(2) template <class F>
|
||||
constexpr <a href='doc_optional.md#optional.hpp'>detail::invoke_result_t<F, T></a> and_then(F&& f) const &&;</code></pre>
|
||||
constexpr 'hidden' and_then(F&& f) const &&;</code></pre>
|
||||
|
||||
Carries out some operation which returns an optional on the stored object if there is one.
|
||||
|
||||
|
145
optional.hpp
145
optional.hpp
@ -18,20 +18,35 @@
|
||||
#include <utility>
|
||||
|
||||
#if __cplusplus == 201103L || _MSC_VER == 1900
|
||||
/// \exclude
|
||||
#define TL_OPTIONAL_11_CONSTEXPR
|
||||
#else
|
||||
/// \exclude
|
||||
#define TL_OPTIONAL_11_CONSTEXPR constexpr
|
||||
#endif
|
||||
|
||||
#if _MSC_VER == 1900
|
||||
/// \exclude
|
||||
#define TL_OPTIONAL_MSVC_2015_CONSTEXPR
|
||||
#else
|
||||
/// \exclude
|
||||
#define TL_OPTIONAL_MSVC_2015_CONSTEXPR constexpr
|
||||
#endif
|
||||
|
||||
namespace tl {
|
||||
template <class T> class optional;
|
||||
/// \brief Represents an optional with no data; essentially a bool
|
||||
class monostate {};
|
||||
|
||||
/// \brief A tag type to tell optional to construct its value in-place
|
||||
struct in_place_t {
|
||||
explicit in_place_t() = default;
|
||||
};
|
||||
/// \brief A tag to tell optional to construct its value in-place
|
||||
static constexpr in_place_t in_place{};
|
||||
|
||||
template <class T> class optional;
|
||||
|
||||
/// \exclude
|
||||
namespace detail {
|
||||
template <class T> using remove_cv_t = typename std::remove_cv<T>::type;
|
||||
template <class T> using remove_const_t = typename std::remove_const<T>::type;
|
||||
@ -150,17 +165,7 @@ using enable_if_ret_void = enable_if_t<returns_void<T &&, U...>::value>;
|
||||
|
||||
template <class T, class... U>
|
||||
using disable_if_ret_void = enable_if_t<!returns_void<T &&, U...>::value>;
|
||||
} // namespace detail
|
||||
|
||||
struct in_place_t {
|
||||
explicit in_place_t() = default;
|
||||
};
|
||||
static constexpr in_place_t in_place{};
|
||||
|
||||
// [optional.optional], class template optional
|
||||
template <class T> class optional;
|
||||
|
||||
namespace detail {
|
||||
template <class T, class U>
|
||||
using enable_forward_value =
|
||||
detail::enable_if_t<std::is_constructible<T, U &&>::value &&
|
||||
@ -278,156 +283,201 @@ struct is_nothrow_swappable
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// [optional.nullopt], no-value state indicator
|
||||
/// \brief A tag type to represent an empty optional
|
||||
struct nullopt_t {
|
||||
struct do_not_use {};
|
||||
constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
|
||||
};
|
||||
/// \brief Represents an empty optional
|
||||
/// \synopsis static constexpr nullopt_t nullopt;
|
||||
///
|
||||
/// *Examples*:
|
||||
/// ```
|
||||
/// tl::optional<int> a = tl::nullopt;
|
||||
/// void foo (tl::optional<int>);
|
||||
/// foo(tl::nullopt); //pass an empty optional
|
||||
/// ```
|
||||
static constexpr nullopt_t nullopt{nullopt_t::do_not_use{},
|
||||
nullopt_t::do_not_use{}};
|
||||
|
||||
// [optional.bad.access], class bad_optional_access
|
||||
class bad_optional_access : public std::exception {
|
||||
public:
|
||||
bad_optional_access() = default;
|
||||
const char *what() const noexcept { return "Optional has no value"; }
|
||||
};
|
||||
|
||||
// [optional.relops], relational operators
|
||||
/// \group relop
|
||||
/// \brief Compares two optional objects
|
||||
/// \details If both optionals contain a value, they are compared with `T`s relational operators.
|
||||
/// Otherwise `lhs` and `rhs` are equal only if they are both empty, and `lhs` is less than `rhs`
|
||||
/// only if `rhs` is empty and `lhs` is not.
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator==(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return lhs.has_value() == rhs.has_value() &&
|
||||
(!lhs.has_value() || *lhs == *rhs);
|
||||
}
|
||||
/// \group relop
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator!=(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return lhs.has_value() != rhs.has_value() ||
|
||||
(lhs.has_value() && *lhs != *rhs);
|
||||
}
|
||||
/// \group relop
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
|
||||
}
|
||||
/// \group relop
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
|
||||
}
|
||||
/// \group relop
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<=(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
|
||||
}
|
||||
/// \group relop
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>=(const optional<T> &lhs,
|
||||
const optional<U> &rhs) {
|
||||
return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
|
||||
}
|
||||
|
||||
// [optional.nullops], comparison with nullopt
|
||||
/// \group relop_nullopt
|
||||
/// \brief Compares an optional to a `nullopt`
|
||||
/// \details Equivalent to comparing the optional to an empty optional
|
||||
template <class T>
|
||||
inline constexpr bool operator==(const optional<T> &lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator==(nullopt_t, const optional<T> &rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator!=(const optional<T> &lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator!=(nullopt_t, const optional<T> &rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator<(const optional<T> &, nullopt_t) noexcept {
|
||||
return false;
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator<(nullopt_t, const optional<T> &rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator<=(const optional<T> &lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator<=(nullopt_t, const optional<T> &) noexcept {
|
||||
return true;
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator>(const optional<T> &lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator>(nullopt_t, const optional<T> &) noexcept {
|
||||
return false;
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator>=(const optional<T> &, nullopt_t) noexcept {
|
||||
return true;
|
||||
}
|
||||
/// \group relop_nullopt
|
||||
template <class T>
|
||||
inline constexpr bool operator>=(nullopt_t, const optional<T> &rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
|
||||
// [optional.comp_with_t], comparison with T
|
||||
|
||||
/// \group relop_t
|
||||
/// \brief Compares the optional with a value.
|
||||
/// \details If the optional has a value, it is compared with the other value using `T`s relational operators.
|
||||
/// Otherwise, the optional is considered less than the value.
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator==(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs == rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator==(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs == *rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator!=(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs != rhs : true;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator!=(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs != *rhs : true;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs < rhs : true;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs < *rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<=(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs <= rhs : true;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<=(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs <= *rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs > rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs > *rhs : true;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>=(const optional<T> &lhs, const U &rhs) {
|
||||
return lhs.has_value() ? *lhs >= rhs : false;
|
||||
}
|
||||
/// \group relop_t
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>=(const U &lhs, const optional<T> &rhs) {
|
||||
return rhs.has_value() ? lhs >= *rhs : true;
|
||||
}
|
||||
|
||||
// [optional.specalg], specialized algorithms
|
||||
/// \synopsis template <class T>\nvoid swap(optional<T> &lhs, optional<T> &rhs);
|
||||
template <class T,
|
||||
detail::enable_if_t<std::is_move_constructible<T>::value> * = nullptr,
|
||||
detail::enable_if_t<detail::is_swappable<T>::value> * = nullptr>
|
||||
@ -451,7 +501,6 @@ inline constexpr optional<T> make_optional(std::initializer_list<U> il,
|
||||
}
|
||||
} // namespace tl
|
||||
|
||||
// [optional.hash], hash support
|
||||
namespace std {
|
||||
// TODO SFINAE
|
||||
template <class T> struct hash<tl::optional<T>> {
|
||||
@ -459,12 +508,13 @@ template <class T> struct hash<tl::optional<T>> {
|
||||
if (!o.has_value())
|
||||
return 0;
|
||||
|
||||
return hash<tl::detail::remove_const_t<T>>()(*o);
|
||||
return std::hash<tl::detail::remove_const_t<T>>()(*o);
|
||||
}
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
namespace tl {
|
||||
/// \exclude
|
||||
namespace detail {
|
||||
template <class T, bool = ::std::is_trivially_destructible<T>::value>
|
||||
struct optional_storage_base {
|
||||
@ -511,15 +561,24 @@ template <class T> struct optional_storage_base<T, true> {
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
|
||||
/// 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.
|
||||
template <class T> class optional : private detail::optional_storage_base<T> {
|
||||
using base = detail::optional_storage_base<T>;
|
||||
|
||||
public:
|
||||
using value_type = T;
|
||||
|
||||
// [optional.ctor], constructors
|
||||
/// Constructs an optional that does not contain a value.
|
||||
constexpr optional() noexcept = default;
|
||||
|
||||
/// Constructs an optional that does not contain a value.
|
||||
constexpr optional(nullopt_t) noexcept {};
|
||||
|
||||
/// Copy constructor
|
||||
///
|
||||
/// If `rhs` contains a value, the stored value is direct-initialized with it.
|
||||
/// Otherwise, the constructed optional is empty.
|
||||
TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_has_value = true;
|
||||
@ -528,6 +587,10 @@ public:
|
||||
}
|
||||
|
||||
// TODO conditionally disable
|
||||
/// Move constructor
|
||||
///
|
||||
/// If `rhs` contains a value, the stored value is direct-initialized with it.
|
||||
/// Otherwise, the constructed optional is empty.
|
||||
TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) noexcept(
|
||||
std::is_nothrow_move_constructible<T>::value) {
|
||||
if (rhs.has_value()) {
|
||||
@ -594,10 +657,8 @@ public:
|
||||
new (std::addressof(this->m_value)) T(std::move(*rhs));
|
||||
}
|
||||
|
||||
// [optional.dtor], destructor
|
||||
~optional() = default;
|
||||
|
||||
// [optional.assign], assignment
|
||||
optional &operator=(nullopt_t) noexcept {
|
||||
if (has_value()) {
|
||||
this->m_value.~T();
|
||||
@ -706,7 +767,6 @@ public:
|
||||
new (std::addressof(this->m_value)) T(il, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
// [optional.swap], swap
|
||||
void
|
||||
swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
|
||||
&&detail::is_nothrow_swappable<T>::value) {
|
||||
@ -724,7 +784,6 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
// [optional.observe], observers
|
||||
constexpr const T *operator->() const {
|
||||
return std::addressof(this->m_value);
|
||||
}
|
||||
@ -774,7 +833,6 @@ public:
|
||||
return has_value() ? **this : static_cast<T>(std::forward<U>(u));
|
||||
}
|
||||
|
||||
// [optional.mod], modifiers
|
||||
void reset() noexcept {
|
||||
if (has_value()) {
|
||||
this->m_value.~T();
|
||||
@ -782,6 +840,11 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// \group and_then
|
||||
/// Carries out some operation which returns an optional on the stored object if there is one.
|
||||
/// \requires `std::invoke(std::forward<F>(f), value())` returns a `std::optional<U>` for some `U`.
|
||||
/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f), value())`. Returns a `std::optional<U>`. The return value is empty if `*this` is empty, otherwise the return value of `std::invoke(std::forward<F>(f), value())` is returned.
|
||||
template <class F>
|
||||
TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T> and_then(F &&f) & {
|
||||
using result = detail::invoke_result_t<F, T>;
|
||||
@ -792,6 +855,10 @@ public:
|
||||
: result(nullopt);
|
||||
}
|
||||
|
||||
/// \group and_then_rval
|
||||
/// Carries out some operation which returns an optional on the stored object if there is one.
|
||||
/// \requires `std::invoke(std::forward<F>(f), std::move(value()))` returns a `std::optional<U>` for some `U`.
|
||||
/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f), std::move(value()))`. Returns a `std::optional<U>`. The return value is empty if `*this` is empty, otherwise the return value of `std::invoke(std::forward<F>(f), std::move(value()))` is returned.
|
||||
template <class F>
|
||||
TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T> and_then(F &&f) && {
|
||||
using result = detail::invoke_result_t<F, T>;
|
||||
@ -802,6 +869,7 @@ public:
|
||||
: result(nullopt);
|
||||
}
|
||||
|
||||
/// \group and_then
|
||||
template <class F>
|
||||
constexpr detail::invoke_result_t<F, T> and_then(F &&f) const & {
|
||||
using result = detail::invoke_result_t<F, T>;
|
||||
@ -812,6 +880,7 @@ public:
|
||||
: result(nullopt);
|
||||
}
|
||||
|
||||
/// \group and_then_rval
|
||||
template <class F>
|
||||
constexpr detail::invoke_result_t<F, T> and_then(F &&f) const && {
|
||||
using result = detail::invoke_result_t<F, T>;
|
||||
@ -822,6 +891,10 @@ public:
|
||||
: result(nullopt);
|
||||
}
|
||||
|
||||
/// \group map
|
||||
/// \synopsis template <class F> auto map(F &&f) &;
|
||||
/// \brief 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<U>`. The return value is empty if `*this` is empty, otherwise an `optional<U>` is constructed from the return value of `std::invoke(std::forward<F>(f), value())` and is returned.
|
||||
template <class F, detail::disable_if_optional<F> * = nullptr,
|
||||
detail::disable_if_ret_void<F, T &> * = nullptr>
|
||||
detail::get_map_return<F, T &> map(F &&f) &
|
||||
@ -861,6 +934,10 @@ public:
|
||||
return monostate{};
|
||||
}
|
||||
|
||||
/// \group map_rval
|
||||
/// \synopsis template <class F> auto map(F &&f) &;
|
||||
/// \brief 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), std::move(value()))`. Returns a `std::optional<U>`. The return value is empty if `*this` is empty, otherwise an `optional<U>` is constructed from the return value of `std::invoke(std::forward<F>(f), std::move(value()))` and is returned.
|
||||
template <class F, detail::disable_if_optional<F> * = nullptr,
|
||||
detail::disable_if_ret_void<F, T &&> * = nullptr>
|
||||
detail::get_map_return<F, T &&> map(F &&f) && {
|
||||
@ -898,6 +975,8 @@ public:
|
||||
return monostate{};
|
||||
}
|
||||
|
||||
/// \group map
|
||||
/// \synopsis template <class F> auto map(F &&f) const &;
|
||||
template <class F, detail::disable_if_optional<F> * = nullptr,
|
||||
detail::disable_if_ret_void<F, T const &> * = nullptr>
|
||||
constexpr detail::get_map_return<F, T const &> map(F &&f) const & {
|
||||
@ -936,6 +1015,8 @@ public:
|
||||
return monostate{};
|
||||
}
|
||||
|
||||
/// \group map_rval
|
||||
/// \synopsis template <class F> auto map(F &&f) const &&;
|
||||
template <class F, detail::disable_if_optional<F> * = nullptr,
|
||||
detail::disable_if_ret_void<F, T const &&> * = nullptr>
|
||||
constexpr detail::get_map_return<F, T const &&> map(F &&f) const && {
|
||||
@ -973,6 +1054,11 @@ public:
|
||||
return monostate{};
|
||||
}
|
||||
|
||||
/// \group or_else
|
||||
/// \brief Calls `f` if the optional is empty
|
||||
/// \synopsis template <class F> optional<T> or_else (F &&f) &;
|
||||
/// \requires `std::invoke_result_t<F>` must be void or convertible to `optional<T>`.
|
||||
/// \effects 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)()`.
|
||||
template <class F, detail::enable_if_ret_void<F> * = nullptr>
|
||||
optional<T> TL_OPTIONAL_MSVC_2015_CONSTEXPR or_else(F &&f) & {
|
||||
if (has_value())
|
||||
@ -987,6 +1073,11 @@ public:
|
||||
return has_value() ? *this : std::forward<F>(f)();
|
||||
}
|
||||
|
||||
/// \group or_else_rval
|
||||
/// \brief Calls `f` if the optional is empty
|
||||
/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
|
||||
/// \requires `std::invoke_result_t<F>` must be void or convertible to `optional<T>`.
|
||||
/// \effects If `*this` has a value, returns `std::move(*this)`. Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
|
||||
template <class F, detail::enable_if_ret_void<F> * = nullptr>
|
||||
optional<T> or_else(F &&f) && {
|
||||
if (has_value())
|
||||
@ -1001,6 +1092,8 @@ public:
|
||||
return has_value() ? std::move(*this) : std::forward<F>(f)();
|
||||
}
|
||||
|
||||
/// \group or_else
|
||||
/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
|
||||
template <class F, detail::enable_if_ret_void<F> * = nullptr>
|
||||
optional<T> or_else(F &&f) const & {
|
||||
if (has_value())
|
||||
@ -1015,6 +1108,8 @@ public:
|
||||
return has_value() ? *this : std::forward<F>(f)();
|
||||
}
|
||||
|
||||
/// \group or_else_rval
|
||||
/// \synopsis template <class F> optional<T> or_else (F &&f) const &&;
|
||||
template <class F, detail::enable_if_ret_void<F> * = nullptr>
|
||||
optional<T> or_else(F &&f) const && {
|
||||
if (has_value())
|
||||
|
Reference in New Issue
Block a user