Template Class expected

Defined in File expected.hpp

Inheritance Relationships

Base Types

private tl::detail::expected_move_assign_base< T, E >
private tl::detail::expected_delete_ctor_base< T, E >
private tl::detail::expected_delete_assign_base< T, E >
private tl::detail::expected_default_ctor_base< T, E >

Class Documentation

template<class T, class E> class expected : private tl::detail::expected_move_assign_base<T, E>, private tl::detail::expected_delete_ctor_base<T, E>, private tl::detail::expected_delete_assign_base<T, E>, private tl::detail::expected_default_ctor_base<T, E>

An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T. Alternatively it could contain the storage for another unexpected object E. The contained object may not be initialized after the expected object has been initialized, and may not be destroyed before the expected object has been destroyed. The initialization state of the contained object is tracked by the expected object.

Public Types

typedef T value_type

typedef E error_type

typedef unexpected<E> unexpected_type

Public Functions

template<class F> inline TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected&>(), std::forward<F>(f)))

template<class F> inline TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected&&>(), std::forward<F>(f)))

template<class F> inline constexpr auto and_then(F &&f) const & -> decltype(and_then_impl(std::declval<expected const&>(), std::forward<F>(f)))

template<class F> inline constexpr auto and_then(F &&f) const && -> decltype(and_then_impl(std::declval<expected const&&>(), std::forward<F>(f)))

template<class F> inline TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval< expected >(), std::declval< F && >())) map (F &&f) &&

template<class F> inline TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval< expected >(), std::declval< F && >())) transform (F &&f) &&

template<class F> inline expected TL_EXPECTED_11_CONSTEXPR or_else (F &&f) &

template<class F> inline expected TL_EXPECTED_11_CONSTEXPR or_else (F &&f) &&

template<class F> inline expected constexpr or_else(F &&f) const &

template<class F> inline expected constexpr or_else(F &&f) const &&

constexpr expected() = default

constexpr expected(const expected &rhs) = default

constexpr expected(expected &&rhs) = default

expected &operator=(const expected &rhs) = default

expected &operator=(expected &&rhs) = default

template<class ...Args, detail::enable_if_t<std::is_constructible<T, Args&&...>::value>* = nullptr> inline constexpr expected(in_place_t, Args&&... args)

template<class U, class ...Args, detail::enable_if_t<std::is_constructible<T, std::initializer_list&, Args&&...>::value>* = nullptr> inline constexpr expected(in_place_t, std::initializer_list il, Args&&... args)

template<class G = E, detail::enable_if_t<std::is_constructible<E, const G&>::value>* = nullptr, detail::enable_if_t<!std::is_convertible<const G&, E>::value>* = nullptr> inline explicit constexpr expected(const unexpected<G> &e)

template<class G = E, detail::enable_if_t<std::is_constructible<E, const G&>::value>* = nullptr, detail::enable_if_t<std::is_convertible<const G&, E>::value>* = nullptr> inline constexpr expected(unexpected<G> const &e)

template<class G = E, detail::enable_if_t<std::is_constructible<E, G&&>::value>* = nullptr, detail::enable_if_t<!std::is_convertible<G&&, E>::value>* = nullptr> inline explicit constexpr expected(unexpected<G> &&e) noexcept(std::is_nothrow_constructible<E, G&&>::value)

template<class G = E, detail::enable_if_t<std::is_constructible<E, G&&>::value>* = nullptr, detail::enable_if_t<std::is_convertible<G&&, E>::value>* = nullptr> inline constexpr expected(unexpected<G> &&e) noexcept(std::is_nothrow_constructible<E, G&&>::value)

template<class ...Args, detail::enable_if_t<std::is_constructible<E, Args&&...>::value>* = nullptr> inline explicit constexpr expected(unexpect_t, Args&&... args)

template<class U, class ...Args, detail::enable_if_t<std::is_constructible<E, std::initializer_list&, Args&&...>::value>* = nullptr> inline explicit constexpr expected(unexpect_t, std::initializer_list il, Args&&... args)

template<class U, class G, detail::enable_if_t<!(std::is_convertible::value && std::is_convertible<G const&, E>::value)>* = nullptr, detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr> inline explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)

template<class U, class G, detail::enable_if_t<(std::is_convertible::value && std::is_convertible<G const&, E>::value)>* = nullptr, detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr> inline TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)

template<class U, class G, detail::enable_if_t<!(std::is_convertible<U&&, T>::value && std::is_convertible<G&&, E>::value)>* = nullptr, detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr> inline explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)

template<class U, class G, detail::enable_if_t<(std::is_convertible<U&&, T>::value && std::is_convertible<G&&, E>::value)>* = nullptr, detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr> inline TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)

template<class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::expected_enable_forward_value<T, E, U>* = nullptr> inline explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)

template<class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::expected_enable_forward_value<T, E, U>* = nullptr> inline TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)

template<class U = T, class G = T, detail::enable_if_t<std::is_nothrow_constructible<T, U&&>::value>* = nullptr, detail::enable_if_t<!std::is_void<G>::value>* = nullptr, detail::enable_if_t<(!std::is_same<expected<T, E>, detail::decay_t>::value && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t>>::value && std::is_constructible<T, U>::value && std::is_assignable<G&, U>::value && std::is_nothrow_move_constructible<E>::value)>* = nullptr> inline expected &operator=(U &&v)

template<class U = T, class G = T, detail::enable_if_t<!std::is_nothrow_constructible<T, U&&>::value>* = nullptr, detail::enable_if_t<!std::is_void::value>* = nullptr, detail::enable_if_t<(!std::is_same<expected<T, E>, detail::decay_t>::value && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t>>::value && std::is_constructible<T, U>::value && std::is_assignable<G&, U>::value && std::is_nothrow_move_constructible<E>::value)>* = nullptr> inline expected &operator=(U &&v)

template<class G = E, detail::enable_if_t<std::is_nothrow_copy_constructible<G>::value && std::is_assignable<G&, G>::value>* = nullptr> inline expected &operator=(const unexpected<G> &rhs)

template<class G = E, detail::enable_if_t<std::is_nothrow_move_constructible<G>::value && std::is_move_assignable<G>::value>* = nullptr> inline expected &operator=(unexpected<G> &&rhs) noexcept

template<class ...Args, detail::enable_if_t<std::is_nothrow_constructible<T, Args&&...>::value>* = nullptr> inline void emplace(Args&&... args)

template<class ...Args, detail::enable_if_t<!std::is_nothrow_constructible<T, Args&&...>::value>* = nullptr> inline void emplace(Args&&... args)

template<class U, class ...Args, detail::enable_if_t<std::is_nothrow_constructible<T, std::initializer_list&, Args&&...>::value>* = nullptr> inline void emplace(std::initializer_list il, Args&&... args)

template<class U, class ...Args, detail::enable_if_t<!std::is_nothrow_constructible<T, std::initializer_list&, Args&&...>::value>* = nullptr> inline void emplace(std::initializer_list il, Args&&... args)

template<class OT = T, class OE = E> inline detail::enable_if_t<detail::is_swappable<OT>::value && detail::is_swappable<OE>::value && (std::is_nothrow_move_constructible<OT>::value || std::is_nothrow_move_constructible<OE>::value)> swap(expected &rhs) noexcept(std::is_nothrow_move_constructible<T>::value && detail::is_nothrow_swappable<T>::value && std::is_nothrow_move_constructible<E>::value && detail::is_nothrow_swappable<E>::value)

inline constexpr const T *operator->() const

inline TL_EXPECTED_11_CONSTEXPR T * operator-> ()

template<class U = T, detail::enable_if_t<!std::is_void::value>* = nullptr> inline constexpr const U &operator*() const &

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR U & operator* () &

template<class U = T, detail::enable_if_t<!std::is_void::value>* = nullptr> inline constexpr const U &&operator*() const &&

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR U && operator* () &&

inline constexpr bool has_value() const noexcept

inline explicit constexpr operator bool() const noexcept

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR const U & value () const &

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR U & value () &

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR const U && value () const &&

template<class U = T, detail::enable_if_t<!std::is_void::value > * = nullptr> inline TL_EXPECTED_11_CONSTEXPR U && value () &&

inline constexpr const E &error() const &

inline TL_EXPECTED_11_CONSTEXPR E & error () &

inline constexpr const E &&error() const &&

inline TL_EXPECTED_11_CONSTEXPR E && error () &&

template<class U> inline constexpr T value_or(U &&v) const &

template<class U> inline TL_EXPECTED_11_CONSTEXPR T value_or (U &&v) &&

Public Members

template<class F> TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval< expected & >(), std::declval< F && >())) map (F &&f) &

template<class F> constexpr decltype(expected_map_impl(std::declval<const expected&>(), std::declval<F&&>())) map(F &&f) const &

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

template<class F> TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval< expected & >(), std::declval< F && >())) transform (F &&f) &

template<class F> constexpr decltype(expected_map_impl(std::declval<const expected&>(), std::declval<F&&>())) transform(F &&f) const &

template<class F> constexpr decltype(expected_map_impl(std::declval<const expected&&>(), std::declval<F&&>())) transform(F &&f) const &&

template<class F> TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval< expected & >(), std::declval< F && >())) map_error (F &&f) &

template<class F> TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval< expected && >(), std::declval< F && >())) map_error (F &&f) &&

template<class F> constexpr decltype(map_error_impl(std::declval<const expected&>(), std::declval<F&&>())) map_error(F &&f) const &

template<class F> constexpr decltype(map_error_impl(std::declval<const expected&&>(), std::declval<F&&>())) map_error(F &&f) const &&