Skip to content

expected


expected class (tl::expected)

template <class T, class E> expected

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.


monostate class (tl::monostate)

monostate

in_place_t class (tl::in_place_t)

in_place_t

unexpected class (tl::unexpected)

template <class E> unexpected

unexpect_t class (tl::unexpect_t)

unexpect_t

conjunction class (tl::detail::conjunction)

template <class> conjunction

template <class B> conjunction

template <class B, class... Bs> conjunction

invoke_result_impl class (tl::detail::invoke_result_impl)

template <class F, class, class... Us> invoke_result_impl

template <class F, class... Us> invoke_result_impl

tag class (tl::detail::swap_adl_tests::tag)

tag

is_std_swap_noexcept class (tl::detail::swap_adl_tests::is_std_swap_noexcept)

template <class T> is_std_swap_noexcept

template <class T, std::size_t N> is_std_swap_noexcept

is_adl_swap_noexcept class (tl::detail::swap_adl_tests::is_adl_swap_noexcept)

template <class T, class U> is_adl_swap_noexcept

is_swappable class (tl::detail::is_swappable)

template <class T, class U = T> is_swappable

template <class T, std::size_t N> is_swappable

is_nothrow_swappable class (tl::detail::is_nothrow_swappable)

template <class T, class U = T> is_nothrow_swappable

is_expected_impl class (tl::detail::is_expected_impl)

template <class T> is_expected_impl

template <class T, class E> is_expected_impl

no_init_t class (tl::detail::no_init_t)

no_init_t

expected_storage_base class (tl::detail::expected_storage_base)

template <class T, class E,
          bool = std::is_trivially_destructible<T>::value,
          bool = std::is_trivially_destructible<E>::value>
expected_storage_base

template <class T, class E> expected_storage_base

template <class T, class E> expected_storage_base

template <class T, class E> expected_storage_base

template <class E> expected_storage_base

dummy class (tl::detail::expected_storage_base::dummy)

dummy

expected_storage_base class (tl::detail::expected_storage_base)

template <class E> expected_storage_base

expected_operations_base class (tl::detail::expected_operations_base)

template <class T, class E> expected_operations_base

template <class E> expected_operations_base

expected_copy_base class (tl::detail::expected_copy_base)

template <
    class T, class E,
    bool =
        is_void_or<
            T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
                   T)>::value &&
        TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
            E)::value>
expected_copy_base

template <class T, class E> expected_copy_base

expected_move_base class (tl::detail::expected_move_base)

template <
    class T, class E,
    bool =
        is_void_or<T, std::is_trivially_move_constructible<
                          T>>::value &&
        std::is_trivially_move_constructible<E>::value>
expected_move_base

template <class T, class E> expected_move_base

expected_copy_assign_base class (tl::detail::expected_copy_assign_base)

template <
    class T, class E,
    bool =
        is_void_or<
            T,
            conjunction<
                TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
                TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
                    T),
                TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::
            value &&
        TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(
            E)::value &&
        TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
            E)::value &&
        TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
expected_copy_assign_base

template <class T, class E> expected_copy_assign_base

expected_move_assign_base class (tl::detail::expected_move_assign_base)

template <
    class T, class E,
    bool =
        is_void_or<
            T, conjunction<
                   std::is_trivially_destructible<T>,
                   std::is_trivially_move_constructible<T>,
                   std::is_trivially_move_assignable<T>>>::
            value &&
        std::is_trivially_destructible<E>::value &&
        std::is_trivially_move_constructible<E>::value &&
        std::is_trivially_move_assignable<E>::value>
expected_move_assign_base

template <class T, class E> expected_move_assign_base

expected_delete_ctor_base class (tl::detail::expected_delete_ctor_base)

template <class T, class E,
          bool EnableCopy =
              (is_copy_constructible_or_void<T>::value &&
               std::is_copy_constructible<E>::value),
          bool EnableMove =
              (is_move_constructible_or_void<T>::value &&
               std::is_move_constructible<E>::value)>
expected_delete_ctor_base

template <class T, class E> expected_delete_ctor_base

template <class T, class E> expected_delete_ctor_base

template <class T, class E> expected_delete_ctor_base

expected_delete_assign_base class (tl::detail::expected_delete_assign_base)

template <class T, class E,
          bool EnableCopy =
              (is_copy_constructible_or_void<T>::value &&
               std::is_copy_constructible<E>::value &&
               is_copy_assignable_or_void<T>::value &&
               std::is_copy_assignable<E>::value),
          bool EnableMove =
              (is_move_constructible_or_void<T>::value &&
               std::is_move_constructible<E>::value &&
               is_move_assignable_or_void<T>::value &&
               std::is_move_assignable<E>::value)>
expected_delete_assign_base

template <class T, class E> expected_delete_assign_base

template <class T, class E> expected_delete_assign_base

template <class T, class E> expected_delete_assign_base

default_constructor_tag class (tl::detail::default_constructor_tag)

default_constructor_tag

expected_default_ctor_base class (tl::detail::expected_default_ctor_base)

template <class T, class E,
          bool Enable =
              std::is_default_constructible<T>::value ||
              std::is_void<T>::value>
expected_default_ctor_base

template <class T, class E> expected_default_ctor_base

bad_expected_access class (tl::bad_expected_access)

template <class E> bad_expected_access

expected class (tl::expected)

template <class T, class E> expected

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.


Auto-generated from sources, Revision , https://github.com/kfrlib/kfr/blob//include/kfr/