asmgrader::Expected< T, E > Class Template Reference

std::variant wrapper for a partial implementation of C++23's expected type More...

#include <expected.hpp>

Public Types
using	ExpectedT = T
using	ErrT = E

Public Member Functions
constexpr	Expected ()
template<typename... Args> requires (!std::is_void_v<T> && std::constructible_from<ExpectedT, Args...>)
constexpr	Expected (std::in_place_t, Args &&... args)
template<typename Tu > requires (!std::is_void_v<T> && std::convertible_to<Tu, T>)
constexpr	Expected (Tu &&value)
template<typename Eu > requires (std::convertible_to<Eu, E> && !std::is_convertible_v<T, E> && !std::is_convertible_v<T, E>)
constexpr	Expected (Eu &&error)
template<typename Eu > requires (std::convertible_to<Eu, E>)
constexpr	Expected (UnexpectedT, Eu &&error)
constexpr void	assert_val ()
constexpr bool	has_value () const
constexpr bool	has_error () const
constexpr	operator bool () const
template<typename U = T> requires (!std::is_void_v<U>)
constexpr U &	value ()
template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U &	value () const
template<typename U = T> requires (std::is_void_v<U>)
constexpr void	value () const
template<typename U = T> requires (!std::is_void_v<U>)
constexpr U &	operator* ()
template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U &	operator* () const
template<typename U = T> requires (!std::is_void_v<U>)
constexpr U *	operator-> ()
template<typename U = T> requires (!std::is_void_v<U>)
constexpr const U *	operator-> () const
template<typename Tu > requires (std::convertible_to<Tu, T>)
constexpr T	value_or (Tu &&default_value) const
constexpr E	error () const
template<typename Eu >
constexpr E	error_or (Eu &&default_value) const
template<typename Func >
constexpr Expected< std::invoke_result_t< Func, T >, E >	transform (const Func &func)
constexpr auto	operator<=> (const Expected &rhs) const =default
constexpr bool	operator== (const Expected &rhs) const
template<typename Tu > requires (!std::is_void_v<T> && !std::same_as<Tu, Expected> && std::equality_comparable_with<Tu, T>)
constexpr bool	operator== (const Tu &rhs) const
template<typename Eu > requires (!std::same_as<Eu, Expected> && std::equality_comparable_with<Eu, E>)
constexpr bool	operator== (const Eu &rhs) const

Detailed Description

template<typename T = void, typename E = std::error_code>
class asmgrader::Expected< T, E >

std::variant wrapper for a partial implementation of C++23's expected type

Template Parameters

T	The expected value type
E	The error type

Note: types T and E must not be convertible between one another.

Member Typedef Documentation

ErrT

template<typename T = void, typename E = std::error_code>

using asmgrader::Expected< T, E >::ErrT = E

ExpectedT

template<typename T = void, typename E = std::error_code>

using asmgrader::Expected< T, E >::ExpectedT = T

Constructor & Destructor Documentation

Expected() [1/5]

template<typename T = void, typename E = std::error_code>

asmgrader::Expected< T, E >::Expected ( )

inlineconstexpr

Expected() [2/5]

template<typename T = void, typename E = std::error_code>

template<typename... Args>
requires (!std::is_void_v<T> && std::constructible_from<ExpectedT, Args...>)

asmgrader::Expected< T, E >::Expected ( std::in_place_t , Args &&... args )

inlineexplicitconstexpr

Expected() [3/5]

template<typename T = void, typename E = std::error_code>

template<typename Tu >
requires (!std::is_void_v<T> && std::convertible_to<Tu, T>)

asmgrader::Expected< T, E >::Expected ( Tu && value )

inlineconstexpr

Expected() [4/5]

template<typename T = void, typename E = std::error_code>

template<typename Eu >
requires (std::convertible_to<Eu, E> && !std::is_convertible_v<T, E> && !std::is_convertible_v<T, E>)

asmgrader::Expected< T, E >::Expected ( Eu && error )

inlineconstexpr

Expected() [5/5]

template<typename T = void, typename E = std::error_code>

template<typename Eu >
requires (std::convertible_to<Eu, E>)

asmgrader::Expected< T, E >::Expected ( UnexpectedT , Eu && error )

inlineconstexpr

Member Function Documentation

assert_val()

template<typename T = void, typename E = std::error_code>

void asmgrader::Expected< T, E >::assert_val ( )

inlineconstexpr

error()

template<typename T = void, typename E = std::error_code>

E asmgrader::Expected< T, E >::error ( ) const

inlineconstexpr

error_or()

template<typename T = void, typename E = std::error_code>

template<typename Eu >

E asmgrader::Expected< T, E >::error_or ( Eu && default_value ) const

inlineconstexpr

has_error()

template<typename T = void, typename E = std::error_code>

bool asmgrader::Expected< T, E >::has_error ( ) const

inlineconstexpr

has_value()

template<typename T = void, typename E = std::error_code>

bool asmgrader::Expected< T, E >::has_value ( ) const

inlineconstexpr

operator bool()

template<typename T = void, typename E = std::error_code>

asmgrader::Expected< T, E >::operator bool ( ) const

inlineexplicitconstexpr

operator*() [1/2]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

U & asmgrader::Expected< T, E >::operator* ( )

inlineconstexpr

operator*() [2/2]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

const U & asmgrader::Expected< T, E >::operator* ( ) const

inlineconstexpr

operator->() [1/2]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

U * asmgrader::Expected< T, E >::operator-> ( )

inlineconstexpr

operator->() [2/2]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

const U * asmgrader::Expected< T, E >::operator-> ( ) const

inlineconstexpr

operator<=>()

template<typename T = void, typename E = std::error_code>

auto asmgrader::Expected< T, E >::operator<=> ( const Expected< T, E > & rhs ) const

constexprdefault

operator==() [1/3]

template<typename T = void, typename E = std::error_code>

template<typename Eu >
requires (!std::same_as<Eu, Expected> && std::equality_comparable_with<Eu, E>)

bool asmgrader::Expected< T, E >::operator== ( const Eu & rhs ) const

inlineconstexpr

operator==() [2/3]

template<typename T = void, typename E = std::error_code>

bool asmgrader::Expected< T, E >::operator== ( const Expected< T, E > & rhs ) const

inlineconstexpr

operator==() [3/3]

template<typename T = void, typename E = std::error_code>

template<typename Tu >
requires (!std::is_void_v<T> && !std::same_as<Tu, Expected> && std::equality_comparable_with<Tu, T>)

bool asmgrader::Expected< T, E >::operator== ( const Tu & rhs ) const

inlineconstexpr

transform()

template<typename T = void, typename E = std::error_code>

template<typename Func >

Expected< std::invoke_result_t< Func, T >, E > asmgrader::Expected< T, E >::transform ( const Func & func )

inlineconstexpr

value() [1/3]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

U & asmgrader::Expected< T, E >::value ( )

inlineconstexpr

value() [2/3]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (!std::is_void_v<U>)

const U & asmgrader::Expected< T, E >::value ( ) const

inlineconstexpr

value() [3/3]

template<typename T = void, typename E = std::error_code>

template<typename U = T>
requires (std::is_void_v<U>)

void asmgrader::Expected< T, E >::value ( ) const

inlineconstexpr

value_or()

template<typename T = void, typename E = std::error_code>

template<typename Tu >
requires (std::convertible_to<Tu, T>)

T asmgrader::Expected< T, E >::value_or ( Tu && default_value ) const

inlineconstexpr

---

The documentation for this class was generated from the following file:

• include/asmgrader/common/expected.hpp