Android-cuttlefish cvd tool
Public Types | Public Member Functions | Private Attributes | Friends | List of all members
android::base::expected< void, E > Class Template Reference

#include <expected.h>

Public Types

using value_type = void
 
using error_type = E
 
using unexpected_type = unexpected< E >
 

Public Member Functions

constexpr expected ()=default
 
constexpr expected (const expected &rhs)=default
 
constexpr expected (expected &&rhs) noexcept=default
 
template<class U , class G _ENABLE_IF>
constexpr expected (const expected< U, G > &rhs)
 
template<class U , class G _ENABLE_IF>
constexpr expected (const expected< U, G > &rhs)
 
template<class U , class G _ENABLE_IF>
constexpr expected (expected< U, G > &&rhs)
 
template<class U , class G _ENABLE_IF>
constexpr expected (expected< U, G > &&rhs)
 
template<class G = E _ENABLE_IF( std::is_constructible_v<E, const G&> && std::is_convertible_v<const G&, E> )>
constexpr expected (const unexpected< G > &e)
 
template<class G = E _ENABLE_IF( std::is_constructible_v<E, const G&> && !std::is_convertible_v<const G&, E> )>
constexpr expected (const unexpected< G > &e)
 
template<class G = E _ENABLE_IF( std::is_constructible_v<E, G&&> && std::is_convertible_v<G&&, E> )>
constexpr expected (unexpected< G > &&e)
 
template<class G = E _ENABLE_IF( std::is_constructible_v<E, G&&> && !std::is_convertible_v<G&&, E> )>
constexpr expected (unexpected< G > &&e)
 
template<class... Args _ENABLE_IF>
constexpr expected (std::in_place_t, Args &&...)
 
template<class... Args _ENABLE_IF>
constexpr expected (unexpect_t, Args &&... args)
 
template<class U , class... Args _ENABLE_IF>
constexpr expected (unexpect_t, std::initializer_list< U > il, Args &&... args)
 
 ~expected ()=default
 
expected & operator= (const expected &rhs)=default
 
expected & operator= (expected &&rhs) noexcept(std::is_nothrow_move_assignable_v< E >)=default
 
template<class G = E>
expected & operator= (const unexpected< G > &rhs)
 
template<class G = E _ENABLE_IF( std::is_nothrow_move_constructible_v<G> && std::is_move_assignable_v<G> )>
expected & operator= (unexpected< G > &&rhs)
 
void emplace ()
 
template<typename = std::enable_if_t< std::is_swappable_v<E>>>
void swap (expected &rhs) noexcept(std::is_nothrow_move_constructible_v< E >)
 
constexpr bool has_value () const noexcept
 
constexpr bool ok () const noexcept
 
constexpr void value () const &
 
constexpr const E & error () const &
 
constexpr E & error () &
 
constexpr const E && error () const &&
 
constexpr E && error () &&
 

Private Attributes

std::variant< std::monostate, unexpected_type > var_
 

Friends

template<class E1 , class E2 >
constexpr bool operator== (const expected< void, E1 > &x, const expected< void, E2 > &y)
 
template<class T1 , class E1 >
void swap (expected< T1, E1 > &x, expected< T1, E1 > &y) noexcept(noexcept(x.swap(y)))
 

Member Typedef Documentation

◆ error_type

template<class E >
using android::base::expected< void, E >::error_type = E

◆ unexpected_type

template<class E >
using android::base::expected< void, E >::unexpected_type = unexpected<E>

◆ value_type

template<class E >
using android::base::expected< void, E >::value_type = void

Constructor & Destructor Documentation

◆ expected() [1/14]

template<class E >
constexpr android::base::expected< void, E >::expected ( )
constexprdefault

◆ expected() [2/14]

template<class E >
constexpr android::base::expected< void, E >::expected ( const expected< void, E > &  rhs)
constexprdefault

◆ expected() [3/14]

template<class E >
constexpr android::base::expected< void, E >::expected ( expected< void, E > &&  rhs)
constexprdefaultnoexcept

◆ expected() [4/14]

template<class E >
template<class U , class G _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( const expected< U, G > &  rhs)
inlineconstexpr

◆ expected() [5/14]

template<class E >
template<class U , class G _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( const expected< U, G > &  rhs)
inlineexplicitconstexpr

◆ expected() [6/14]

template<class E >
template<class U , class G _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( expected< U, G > &&  rhs)
inlineconstexpr

◆ expected() [7/14]

template<class E >
template<class U , class G _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( expected< U, G > &&  rhs)
inlineexplicitconstexpr

◆ expected() [8/14]

template<class E >
template<class G = E _ENABLE_IF( std::is_constructible_v<E, const G&> && std::is_convertible_v<const G&, E> )>
constexpr android::base::expected< void, E >::expected ( const unexpected< G > &  e)
inlineconstexpr

◆ expected() [9/14]

template<class E >
template<class G = E _ENABLE_IF( std::is_constructible_v<E, const G&> && !std::is_convertible_v<const G&, E> )>
constexpr android::base::expected< void, E >::expected ( const unexpected< G > &  e)
inlineexplicitconstexpr

◆ expected() [10/14]

template<class E >
template<class G = E _ENABLE_IF( std::is_constructible_v<E, G&&> && std::is_convertible_v<G&&, E> )>
constexpr android::base::expected< void, E >::expected ( unexpected< G > &&  e)
inlineconstexpr

◆ expected() [11/14]

template<class E >
template<class G = E _ENABLE_IF( std::is_constructible_v<E, G&&> && !std::is_convertible_v<G&&, E> )>
constexpr android::base::expected< void, E >::expected ( unexpected< G > &&  e)
inlineexplicitconstexpr

◆ expected() [12/14]

template<class E >
template<class... Args _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( std::in_place_t  ,
Args &&  ... 
)
inlineexplicitconstexpr

◆ expected() [13/14]

template<class E >
template<class... Args _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( unexpect_t  ,
Args &&...  args 
)
inlineexplicitconstexpr

◆ expected() [14/14]

template<class E >
template<class U , class... Args _ENABLE_IF>
constexpr android::base::expected< void, E >::expected ( unexpect_t  ,
std::initializer_list< U >  il,
Args &&...  args 
)
inlineexplicitconstexpr

◆ ~expected()

template<class E >
android::base::expected< void, E >::~expected ( )
default

Member Function Documentation

◆ emplace()

template<class E >
void android::base::expected< void, E >::emplace ( )
inline

◆ error() [1/4]

template<class E >
constexpr E & android::base::expected< void, E >::error ( ) &
inlineconstexpr

◆ error() [2/4]

template<class E >
constexpr E && android::base::expected< void, E >::error ( ) &&
inlineconstexpr

◆ error() [3/4]

template<class E >
constexpr const E & android::base::expected< void, E >::error ( ) const &
inlineconstexpr

◆ error() [4/4]

template<class E >
constexpr const E && android::base::expected< void, E >::error ( ) const &&
inlineconstexpr

◆ has_value()

template<class E >
constexpr bool android::base::expected< void, E >::has_value ( ) const
inlineconstexprnoexcept

◆ ok()

template<class E >
constexpr bool android::base::expected< void, E >::ok ( ) const
inlineconstexprnoexcept

◆ operator=() [1/4]

template<class E >
expected & android::base::expected< void, E >::operator= ( const expected< void, E > &  rhs)
default

◆ operator=() [2/4]

template<class E >
template<class G = E>
expected & android::base::expected< void, E >::operator= ( const unexpected< G > &  rhs)
inline

◆ operator=() [3/4]

template<class E >
expected & android::base::expected< void, E >::operator= ( expected< void, E > &&  rhs)
defaultnoexcept

◆ operator=() [4/4]

template<class E >
template<class G = E _ENABLE_IF( std::is_nothrow_move_constructible_v<G> && std::is_move_assignable_v<G> )>
expected & android::base::expected< void, E >::operator= ( unexpected< G > &&  rhs)
inline

◆ swap()

template<class E >
template<typename = std::enable_if_t< std::is_swappable_v<E>>>
void android::base::expected< void, E >::swap ( expected< void, E > &  rhs)
inlinenoexcept

◆ value()

template<class E >
constexpr void android::base::expected< void, E >::value ( ) const &
inlineconstexpr

Friends And Related Function Documentation

◆ operator==

template<class E >
template<class E1 , class E2 >
constexpr bool operator== ( const expected< void, E1 > &  x,
const expected< void, E2 > &  y 
)
friend

◆ swap

template<class E >
template<class T1 , class E1 >
void swap ( expected< T1, E1 > &  x,
expected< T1, E1 > &  y 
)
friend

Member Data Documentation

◆ var_

template<class E >
std::variant<std::monostate, unexpected_type> android::base::expected< void, E >::var_
private
The documentation for this class was generated from the following file:
Generated by doxygen 1.9.4