proxygen: folly::Expected< Value, Error > Class Template Reference

#include <Expected.h>

Inheritance diagram for folly::Expected< Value, Error >:

Public Types
using	value_type = Value

using	error_type = Error

template<class U >
using	rebind = Expected< U, Error >

Public Member Functions
template<class B = Base, class = decltype(B{})>
	Expected () noexcept(noexcept(B{}))

	Expected (const Expected &that)=default

	Expected (Expected &&that)=default

template<class V , class E , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(!std::is_same< Expected< V, E >, Expected >::value &&std::is_constructible< Value, V && >::value &&std::is_constructible< Error, E && >::value)), int >::type = 0>
	Expected (Expected< V, E > that)

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_copy_constructible< Value >::value)), int >::type = 0>
constexpr	Expected (const Value &val) noexcept(noexcept(Value(val)))

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_move_constructible< Value >::value)), int >::type = 0>
constexpr	Expected (Value &&val) noexcept(noexcept(Value(std::move(val))))

template<class T , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_convertible< T, Value >::value &&!std::is_convertible< T, Error >::value)), int >::type = 0>
constexpr	Expected (T &&val) noexcept(noexcept(Value(static_cast< T && >(val))))

template<class... Ts, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_constructible< Value, Ts &&... >::value)), int >::type = 0>
constexpr	Expected (in_place_t, Ts &&...ts) noexcept(noexcept(Value(std::declval< Ts >()...)))

template<class U , class... Ts, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_constructible< Value, std::initializer_list< U > &, Ts &&... >::value)), int >::type = 0>
constexpr	Expected (in_place_t, std::initializer_list< U > il, Ts &&...ts) noexcept(noexcept(Value(std::declval< Ts >()...)))

	Expected (const Error &)=delete

	Expected (Error &&)=delete

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_copy_constructible< Error >::value)), int >::type = 0>
constexpr	Expected (unexpected_t, const Error &err) noexcept(noexcept(Error(err)))

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_move_constructible< Error >::value)), int >::type = 0>
constexpr	Expected (unexpected_t, Error &&err) noexcept(noexcept(Error(std::move(err))))

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_copy_constructible< Error >::value)), int >::type = 0>
constexpr	Expected (const Unexpected< Error > &err) noexcept(noexcept(Error(err.error())))

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_move_constructible< Error >::value)), int >::type = 0>
constexpr	Expected (Unexpected< Error > &&err) noexcept(noexcept(Error(std::move(err.error()))))

Expected &	operator= (const Expected &that)=default

Expected &	operator= (Expected &&that)=default

template<class V , class E , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(!std::is_same< Expected< V, E >, Expected >::value &&expected_detail::IsConvertible< V &&, Value >::value &&expected_detail::IsConvertible< E &&, Error >::value)), int >::type = 0>
Expected &	operator= (Expected< V, E > that)

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(expected_detail::IsCopyable< Value >::value)), int >::type = 0>
Expected &	operator= (const Value &val) noexcept(expected_detail::IsNothrowCopyable< Value >::value)

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(expected_detail::IsMovable< Value >::value)), int >::type = 0>
Expected &	operator= (Value &&val) noexcept(expected_detail::IsNothrowMovable< Value >::value)

template<class T , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_convertible< T, Value >::value &&!std::is_convertible< T, Error >::value)), int >::type = 0>
Expected &	operator= (T &&val)

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(expected_detail::IsCopyable< Error >::value)), int >::type = 0>
Expected &	operator= (const Unexpected< Error > &err) noexcept(expected_detail::IsNothrowCopyable< Error >::value)

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(expected_detail::IsMovable< Error >::value)), int >::type = 0>
Expected &	operator= (Unexpected< Error > &&err) noexcept(expected_detail::IsNothrowMovable< Error >::value)

	Expected (const expected_detail::PromiseReturn< Value, Error > &p)

template<class... Ts, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(std::is_constructible< Value, Ts &&... >::value)), int >::type = 0>
void	emplace (Ts &&...ts)

void	swap (Expected &that) noexcept(expected_detail::StrictAllOf< IsNothrowSwappable, Value, Error >::value)

Expected &	operator= (const Error &)=delete

Expected &	operator= (Error &&)=delete

constexpr bool	hasValue () const noexcept

constexpr bool	hasError () const noexcept

const Value &	value () const &

Value &	value ()&

Value &&	value ()&&

const Error &	error () const &

Error &	error ()&

Error &&	error ()&&

template<class U >
Value	value_or (U &&dflt) const &

template<class U >
Value	value_or (U &&dflt)&&

constexpr	operator bool () const noexcept

const Value &	operator* () const &

Value &	operator* ()&

Value &&	operator* ()&&

const Value *	operator-> () const

Value *	operator-> ()

const Value *	get_pointer () const &noexcept

Value *	get_pointer ()&noexcept

Value *	get_pointer ()&&=delete

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(sizeof...(Fns) > = 1>
auto	then (Fns &&...fns) const &-> decltype(expected_detail::ExpectedHelper::then_(std::declval< const Base & >(), std::declval< Fns >()...))

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(sizeof...(Fns) > = 1>
auto	then (Fns &&...fns)&-> decltype(expected_detail::ExpectedHelper::then_(std::declval< Base & >(), std::declval< Fns >()...))

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)\|\|static_cast< bool >(sizeof...(Fns) > = 1>
auto	then (Fns &&...fns)&&-> decltype(expected_detail::ExpectedHelper::then_(std::declval< Base && >(), std::declval< Fns >()...))

template<class Yes , class No = MakeBadExpectedAccess>
auto	thenOrThrow (Yes &&yes, No &&no=No{}) const &-> decltype(std::declval< Yes >()(std::declval< const Value & >()))

template<class Yes , class No = MakeBadExpectedAccess>
auto	thenOrThrow (Yes &&yes, No &&no=No{})&-> decltype(std::declval< Yes >()(std::declval< Value & >()))

template<class Yes , class No = MakeBadExpectedAccess>
auto	thenOrThrow (Yes &&yes, No &&no=No{})&&-> decltype(std::declval< Yes >()(std::declval< Value && >()))

Private Types
using	Base = expected_detail::ExpectedStorage< Value, Error >

using	MakeBadExpectedAccess = typename Unexpected< Error >::MakeBadExpectedAccess

Private Types inherited from folly::expected_detail::ExpectedStorage< Value, Error >
using	value_type = Value

using	error_type = Error

Private Member Functions
Base &	base ()&

const Base &	base () const &

Base &&	base ()&&

void	requireValue () const

void	requireError () const

expected_detail::Which	which () const noexcept

Private Member Functions inherited from folly::expected_detail::ExpectedStorage< Value, Error >
constexpr	ExpectedStorage () noexcept(noexcept(E{}))

constexpr	ExpectedStorage (EmptyTag) noexcept

constexpr	ExpectedStorage (ValueTag, Vs &&...vs) noexcept(noexcept(Value(static_cast< Vs && >(vs)...)))

constexpr	ExpectedStorage (ErrorTag, Es &&...es) noexcept(noexcept(Error(static_cast< Es && >(es)...)))

void	clear () noexcept

void	assignValue (Vs &&...vs)

void	assignError (Es &&...es)

void	assign (Other &&that)

Value &	value ()&

const Value &	value () const &

Value &&	value ()&&

FOLLY_PUSH_WARNING	FOLLY_MSVC_DISABLE_WARNING (4702) Error &error()&

const Error &	error () const &

Error &&	error ()&&

Friends
template<class , class >
class	Expected

template<class , class , expected_detail::StorageType >
struct	expected_detail::ExpectedStorage

struct	expected_detail::ExpectedHelper

template<class Val , class Err >
std::enable_if< IsEqualityComparable< Val >::value, bool >::type	operator== (const Expected< Val, Err > &lhs, const Expected< Val, Err > &rhs)

template<class Val , class Err >
std::enable_if< IsLessThanComparable< Val >::value, bool >::type	operator< (const Expected< Val, Err > &lhs, const Expected< Val, Err > &rhs)

Additional Inherited Members
Static Private Member Functions inherited from folly::expected_detail::ExpectedStorage< Value, Error >
static constexpr bool	uninitializedByException () noexcept

Private Attributes inherited from folly::expected_detail::ExpectedStorage< Value, Error >
Value	value_

Error	error_

char	ch_

union {
Value value_

Error error_

char ch_

};

Which	which_

Detailed Description

template<class Value, class Error>
class folly::Expected< Value, Error >

Expected - For holding a value or an error. Useful as an alternative to exceptions, for APIs where throwing on failure would be too expensive.

Expected<Value, Error> is a variant over the types Value and Error.

Expected does not offer support for references. Use Expected<std::reference_wrapper<T>, Error> if your API needs to return a reference or an error.

Expected offers a continuation-based interface to reduce the boilerplate of checking error codes. The Expected::then member function takes a lambda that is to execute should the Expected object contain a value. The return value of the lambda is wrapped in an Expected and returned. If the lambda is not executed because the Expected contains an error, the error is returned immediately in a new Expected object.

Expected<int, Error> funcTheFirst(); Expected<std::string, Error> funcTheSecond() { return funcTheFirst().then([](int i) { return std::to_string(i); }); }

The above line of code could more verbosely written as:

Expected<std::string, Error> funcTheSecond() { if (auto ex = funcTheFirst()) { return std::to_string(*ex); } return makeUnexpected(ex.error()); }

Continuations can chain, like:

Expected<D, Error> maybeD = someFunc() .then([](A a){return B(a);}) .then([](B b){return C(b);}) .then([](C c){return D(c);});

To avoid the redundant error checking that would happen if a call at the front of the chain returns an error, these call chains can be collaped into a single call to .then:

Expected<D, Error> maybeD = someFunc() .then([](A a){return B(a);}, [](B b){return C(b);}, [](C c){return D(c);});

The result of .then() is wrapped into Expected< ~, Error > if it isn't of that form already. Consider the following code:

extern Expected<std::string, Error> readLineFromIO(); extern Expected<int, Error> parseInt(std::string); extern int increment(int);

Expected<int, Error> x = readLineFromIO().then(parseInt).then(increment);

From the code above, we see that .then() works both with functions that return an Expected< ~, Error > (like parseInt) and with ones that return a plain value (like increment). In the case of parseInt, .then() returns the result of parseInt as-is. In the case of increment, it wraps the int that increment returns into an Expected< int, Error >.

Sometimes when using a continuation you would prefer an exception to be thrown for a value-less Expected. For that you can use .thenOrThrow, as follows:

B b = someFunc() .thenOrThrow([](A a){return B(a);});

The above call to thenOrThrow will invoke the lambda if the Expected returned by someFunc() contains a value. Otherwise, it will throw an exception of type Unexpected<Error>::BadExpectedAccess. If you prefer it throw an exception of a different type, you can pass a second lambda to thenOrThrow:

B b = someFunc() .thenOrThrow([](A a){return B(a);}, [](Error e) {throw MyException(e);});

Like C++17's std::variant, Expected offers the almost-never-empty guarantee; that is, an Expected<Value, Error> almost always contains either a Value or and Error. Partially-formed Expected objects occur when an assignment to an Expected object that would change the type of the contained object (Value- to-Error or vice versa) throws. Trying to access either the contained value or error object causes Expected to throw folly::BadExpectedAccess.

Expected models OptionalPointee, so calling 'get_pointer(ex)' will return a pointer to nullptr if the 'ex' is in the error state, and a pointer to the value otherwise:

Expected<int, Error> maybeInt = ...; if (int* v = get_pointer(maybeInt)) { cout << *v << endl; }

Definition at line 78 of file Expected.h.

Member Typedef Documentation

template<class Value, class Error>

using folly::Expected< Value, Error >::Base = expected_detail::ExpectedStorage<Value, Error>

private

Definition at line 892 of file Expected.h.

template<class Value, class Error>

using folly::Expected< Value, Error >::error_type = Error

Definition at line 907 of file Expected.h.

template<class Value, class Error>

using folly::Expected< Value, Error >::MakeBadExpectedAccess = typename Unexpected<Error>::MakeBadExpectedAccess

private

Definition at line 894 of file Expected.h.

template<class Value, class Error>

template<class U >

using folly::Expected< Value, Error >::rebind = Expected<U, Error>

Definition at line 910 of file Expected.h.

template<class Value, class Error>

using folly::Expected< Value, Error >::value_type = Value

Definition at line 906 of file Expected.h.

Constructor & Destructor Documentation

template<class Value, class Error>

template<class B = Base, class = decltype(B{})>

folly::Expected< Value, Error >::Expected ( )

inlinenoexcept

Definition at line 923 of file Expected.h.

923 {})) : Base{} {}

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

folly::Expected< Value, Error >::Expected ( const Expected< Value, Error > & that )

default

template<class Value, class Error>

folly::Expected< Value, Error >::Expected ( Expected< Value, Error > && that )

default

template<class Value, class Error>

template<class V , class E , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(!std::is_same< Expected< V, E >, Expected >::value &&std::is_constructible< Value, V && >::value &&std::is_constructible< Error, E && >::value)), int >::type = 0>

folly::Expected< Value, Error >::Expected ( Expected< V, E > that )

inline

Definition at line 933 of file Expected.h.

                                 : Base{expected_detail::EmptyTag{}} {
     *this = std::move(that);
   }

template<class Value, class Error>

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(std::is_copy_constructible< Value >::value)), int >::type = 0>

constexpr folly::Expected< Value, Error >::Expected ( const Value & val )

inlinenoexcept

Definition at line 938 of file Expected.h.

940 : Base{expected_detail::ValueTag{}, val} {}

val

double val

Definition: String.cpp:273

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(std::is_move_constructible< Value >::value)), int >::type = 0>

constexpr folly::Expected< Value, Error >::Expected ( Value && val )

inlinenoexcept

Definition at line 943 of file Expected.h.

945 : Base{expected_detail::ValueTag{}, std::move(val)} {}

folly::gen::move

constexpr detail::Map< Move > move

Definition: Base-inl.h:2567

val

double val

Definition: String.cpp:273

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

template<class T , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(std::is_convertible< T, Value >::value &&!std::is_convertible< T, Error >::value)), int >::type = 0>

constexpr folly::Expected< Value, Error >::Expected ( T && val )

inlinenoexcept

Definition at line 950 of file Expected.h.

952 : Base{expected_detail::ValueTag{}, static_cast<T&&>(val)} {}

val

double val

Definition: String.cpp:273

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

folly::T

folly::std T

template<class Value, class Error>

template<class... Ts, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(std::is_constructible< Value, Ts &&... >::value)), int >::type = 0>

constexpr folly::Expected< Value, Error >::Expected	(	in_place_t	,
		Ts &&...	ts
	)

inlineexplicitnoexcept

Definition at line 956 of file Expected.h.

958 : Base{expected_detail::ValueTag{}, static_cast<Ts&&>(ts)...} {}

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

template<class U , class... Ts, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(std::is_constructible< Value, std::initializer_list< U > &, Ts &&... >::value)), int >::type = 0>

constexpr folly::Expected< Value, Error >::Expected	(	in_place_t	,
		std::initializer_list< U >	il,
		Ts &&...	ts
	)

inlineexplicitnoexcept

Definition at line 965 of file Expected.h.

969 : Base{expected_detail::ValueTag{}, il, static_cast<Ts&&>(ts)...} {}

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

folly::Expected< Value, Error >::Expected ( const Error & )

delete

template<class Value, class Error>

folly::Expected< Value, Error >::Expected ( Error && )

delete

template<class Value, class Error>

constexpr folly::Expected< Value, Error >::Expected	(	unexpected_t	,
		const Error &	err
	)

inlinenoexcept

Definition at line 977 of file Expected.h.

979 : Base{expected_detail::ErrorTag{}, err} {}

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

constexpr folly::Expected< Value, Error >::Expected	(	unexpected_t	,
		Error &&	err
	)

inlinenoexcept

Definition at line 982 of file Expected.h.

984 : Base{expected_detail::ErrorTag{}, std::move(err)} {}

folly::gen::move

constexpr detail::Map< Move > move

Definition: Base-inl.h:2567

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

constexpr folly::Expected< Value, Error >::Expected ( const Unexpected< Error > & err )

inlinenoexcept

Definition at line 987 of file Expected.h.

989 : Base{expected_detail::ErrorTag{}, err.error()} {}

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

folly::expected_detail::ExpectedStorage::error

const Error & error() const &

Definition: Expected.h:255

template<class Value, class Error>

constexpr folly::Expected< Value, Error >::Expected ( Unexpected< Error > && err )

inlinenoexcept

Definition at line 992 of file Expected.h.

994 : Base{expected_detail::ErrorTag{}, std::move(err.error())} {}

folly::gen::move

constexpr detail::Map< Move > move

Definition: Base-inl.h:2567

folly::Expected::Base

expected_detail::ExpectedStorage< Value, Error > Base

Definition: Expected.h:892

template<class Value, class Error>

folly::Expected< Value, Error >::Expected ( const expected_detail::PromiseReturn< Value, Error > & p )

inline

Definition at line 1050 of file Expected.h.

       : Expected{} {
     p.promise_->value_ = this;
   }

Member Function Documentation

template<class Value, class Error>

Base& folly::Expected< Value, Error >::base ( )

inlineprivate

Definition at line 895 of file Expected.h.

                  {
     return *this;
   }

template<class Value, class Error>

const Base& folly::Expected< Value, Error >::base ( ) const

inlineprivate

Definition at line 898 of file Expected.h.

                             {
     return *this;
   }

template<class Value, class Error>

Base&& folly::Expected< Value, Error >::base ( )

inlineprivate

Definition at line 901 of file Expected.h.

                    {
     return std::move(*this);
   }

template<class Value, class Error>

void folly::Expected< Value, Error >::emplace ( Ts &&... ts )

inline

Definition at line 1057 of file Expected.h.

Referenced by folly::TEST().

                            {
     this->assignValue(static_cast<Ts&&>(ts)...);
   }

template<class Value, class Error>

const Error& folly::Expected< Value, Error >::error ( ) const

inline

Definition at line 1132 of file Expected.h.

Referenced by folly::makeExpected(), and folly::TEST().

                               {
     requireError();
     return this->Base::error();
   }

template<class Value, class Error>

Error& folly::Expected< Value, Error >::error ( )

inline

Definition at line 1137 of file Expected.h.

                    {
     requireError();
     return this->Base::error();
   }

template<class Value, class Error>

Error&& folly::Expected< Value, Error >::error ( )

inline

Definition at line 1142 of file Expected.h.

                      {
     requireError();
     return std::move(this->Base::error());
   }

template<class Value, class Error>

const Value* folly::Expected< Value, Error >::get_pointer ( ) const

inlinenoexcept

Definition at line 1188 of file Expected.h.

                                              {
     return hasValue() ? std::addressof(this->value_) : nullptr;
   }

template<class Value, class Error>

Value* folly::Expected< Value, Error >::get_pointer ( )

inlinenoexcept

Definition at line 1192 of file Expected.h.

                                   {
     return hasValue() ? std::addressof(this->value_) : nullptr;
   }

template<class Value, class Error>

Value* folly::Expected< Value, Error >::get_pointer ( )

delete

template<class Value, class Error>

constexpr bool folly::Expected< Value, Error >::hasError ( ) const

inlinenoexcept

Definition at line 1111 of file Expected.h.

Referenced by folly::operator<(), and folly::operator==().

                                            {
     return UNLIKELY(expected_detail::Which::eError == this->which_);
   }

template<class Value, class Error>

constexpr bool folly::Expected< Value, Error >::hasValue ( ) const

inlinenoexcept

Definition at line 1107 of file Expected.h.

Referenced by folly::makeExpected(), and folly::TEST().

                                            {
     return LIKELY(expected_detail::Which::eValue == this->which_);
   }

template<class Value, class Error>

constexpr folly::Expected< Value, Error >::operator bool ( ) const

inlineexplicitnoexcept

Definition at line 1164 of file Expected.h.

                                                     {
     return hasValue();
   }

template<class Value, class Error>

const Value& folly::Expected< Value, Error >::operator* ( ) const

inline

Definition at line 1168 of file Expected.h.

                                   {
     return this->value();
   }

template<class Value, class Error>

Value& folly::Expected< Value, Error >::operator* ( )

inline

Definition at line 1172 of file Expected.h.

                        {
     return this->value();
   }

template<class Value, class Error>

Value&& folly::Expected< Value, Error >::operator* ( )

inline

Definition at line 1176 of file Expected.h.

                          {
     return std::move(this->value());
   }

template<class Value, class Error>

const Value* folly::Expected< Value, Error >::operator-> ( ) const

inline

Definition at line 1180 of file Expected.h.

                                   {
     return std::addressof(this->value());
   }

template<class Value, class Error>

Value* folly::Expected< Value, Error >::operator-> ( )

inline

Definition at line 1184 of file Expected.h.

                       {
     return std::addressof(this->value());
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( const Expected< Value, Error > & that )

default

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( Expected< Value, Error > && that )

default

template<class Value, class Error>

template<class V , class E , bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(!std::is_same< Expected< V, E >, Expected >::value &&expected_detail::IsConvertible< V &&, Value >::value &&expected_detail::IsConvertible< E &&, Error >::value)), int >::type = 0>

Expected& folly::Expected< Value, Error >::operator= ( Expected< V, E > that )

inline

Definition at line 1008 of file Expected.h.

                                            {
     this->assign(std::move(that));
     return *this;
   }

template<class Value, class Error>

template<bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(expected_detail::IsCopyable< Value >::value)), int >::type = 0>

Expected& folly::Expected< Value, Error >::operator= ( const Value & val )

inlinenoexcept

Definition at line 1014 of file Expected.h.

                                                     {
     this->assignValue(val);
     return *this;
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( Value && val )

inlinenoexcept

Definition at line 1021 of file Expected.h.

                                                    {
     this->assignValue(std::move(val));
     return *this;
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( T && val )

inline

Definition at line 1030 of file Expected.h.

                                {
     this->assignValue(static_cast<T&&>(val));
     return *this;
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( const Unexpected< Error > & err )

inlinenoexcept

Definition at line 1036 of file Expected.h.

                                                     {
     this->assignError(err.error());
     return *this;
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( Unexpected< Error > && err )

inlinenoexcept

Definition at line 1043 of file Expected.h.

                                                    {
     this->assignError(std::move(err.error()));
     return *this;
   }

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( const Error & )

delete

template<class Value, class Error>

Expected& folly::Expected< Value, Error >::operator= ( Error && )

delete

template<class Value, class Error>

void folly::Expected< Value, Error >::requireError ( ) const

inlineprivate

Definition at line 1282 of file Expected.h.

                             {
     if (UNLIKELY(!hasError())) {
       throw_exception<BadExpectedAccess>();
     }
   }

template<class Value, class Error>

void folly::Expected< Value, Error >::requireValue ( ) const

inlineprivate

Definition at line 1272 of file Expected.h.

                             {
     if (UNLIKELY(!hasValue())) {
       if (LIKELY(hasError())) {
         using Err = typename Unexpected<Error>::BadExpectedAccess;
         throw_exception<Err>(this->error_);
       }
       throw_exception<BadExpectedAccess>();
     }
   }

template<class Value, class Error>

void folly::Expected< Value, Error >::swap ( Expected< Value, Error > & that )

inlinenoexcept

swap

Definition at line 1064 of file Expected.h.

Referenced by folly::TEST().

                                                                          {
     if (this->uninitializedByException() || that.uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     using std::swap;
     if (*this) {
       if (that) {
         swap(this->value_, that.value_);
       } else {
         Error e(std::move(that.error_));
         that.assignValue(std::move(this->value_));
         this->assignError(std::move(e));
       }
     } else {
       if (!that) {
         swap(this->error_, that.error_);
       } else {
         Error e(std::move(this->error_));
         this->assignValue(std::move(that.value_));
         that.assignError(std::move(e));
       }
     }
   }

template<class Value, class Error>

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(sizeof...(Fns) > = 1>

auto folly::Expected< Value, Error >::then ( Fns &&... fns ) const -> decltype( expected_detail::ExpectedHelper::then_( std::declval<const Base&>(), std::declval<Fns>()...))

inline

then

Definition at line 1202 of file Expected.h.

                                  {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return expected_detail::ExpectedHelper::then_(
         base(), static_cast<Fns&&>(fns)...);
   }

template<class Value, class Error>

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(sizeof...(Fns) > = 1>

auto folly::Expected< Value, Error >::then ( Fns &&... fns ) -> decltype(expected_detail::ExpectedHelper::then_( std::declval<Base&>(), std::declval<Fns>()...))

inline

Definition at line 1214 of file Expected.h.

                              {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return expected_detail::ExpectedHelper::then_(
         base(), static_cast<Fns&&>(fns)...);
   }

template<class Value, class Error>

template<class... Fns, bool FB_CONCATENATE = false, typename std::enable_if< (FB_CONCATENATE(FB_CONCATENATE(Folly, Requires), __LINE__)||static_cast< bool >(sizeof...(Fns) > = 1>

auto folly::Expected< Value, Error >::then ( Fns &&... fns ) -> decltype(expected_detail::ExpectedHelper::then_( std::declval<Base&&>(), std::declval<Fns>()...))

inline

Definition at line 1225 of file Expected.h.

                              {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return expected_detail::ExpectedHelper::then_(
         std::move(base()), static_cast<Fns&&>(fns)...);
   }

template<class Value, class Error>

template<class Yes , class No = MakeBadExpectedAccess>

auto folly::Expected< Value, Error >::thenOrThrow	(	Yes &&	yes,
		No &&	no = `No{}`
	)		const -> decltype( std::declval<Yes>()(std::declval<const Value&>()))

inline

thenOrThrow

Definition at line 1239 of file Expected.h.

                                           {}) const& -> decltype(
       std::declval<Yes>()(std::declval<const Value&>())) {
     using Ret = decltype(std::declval<Yes>()(std::declval<const Value&>()));
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return Ret(expected_detail::ExpectedHelper::thenOrThrow_(
         base(), static_cast<Yes&&>(yes), static_cast<No&&>(no)));
   }

template<class Value, class Error>

template<class Yes , class No = MakeBadExpectedAccess>

auto folly::Expected< Value, Error >::thenOrThrow	(	Yes &&	yes,
		No &&	no = `No{}`
	)		-> decltype( std::declval<Yes>()(std::declval<Value&>()))

inline

Definition at line 1250 of file Expected.h.

                                           {}) & -> decltype(
       std::declval<Yes>()(std::declval<Value&>())) {
     using Ret = decltype(std::declval<Yes>()(std::declval<Value&>()));
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return Ret(expected_detail::ExpectedHelper::thenOrThrow_(
         base(), static_cast<Yes&&>(yes), static_cast<No&&>(no)));
   }

template<class Value, class Error>

template<class Yes , class No = MakeBadExpectedAccess>

auto folly::Expected< Value, Error >::thenOrThrow	(	Yes &&	yes,
		No &&	no = `No{}`
	)		-> decltype( std::declval<Yes>()(std::declval<Value&&>()))

inline

Definition at line 1261 of file Expected.h.

                                           {}) && -> decltype(
       std::declval<Yes>()(std::declval<Value&&>())) {
     using Ret = decltype(std::declval<Yes>()(std::declval<Value&&>()));
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess>();
     }
     return Ret(expected_detail::ExpectedHelper::thenOrThrow_(
         std::move(base()), static_cast<Yes&&>(yes), static_cast<No&&>(no)));
   }

template<class Value, class Error>

const Value& folly::Expected< Value, Error >::value ( ) const

inline

Definition at line 1117 of file Expected.h.

Referenced by folly::makeExpected(), and folly::TEST().

                               {
     requireValue();
     return this->Base::value();
   }

template<class Value, class Error>

Value& folly::Expected< Value, Error >::value ( )

inline

Definition at line 1122 of file Expected.h.

                    {
     requireValue();
     return this->Base::value();
   }

template<class Value, class Error>

Value&& folly::Expected< Value, Error >::value ( )

inline

Definition at line 1127 of file Expected.h.

                      {
     requireValue();
     return std::move(this->Base::value());
   }

template<class Value, class Error>

template<class U >

Value folly::Expected< Value, Error >::value_or ( U && dflt ) const

inline

Definition at line 1149 of file Expected.h.

Referenced by folly::TEST().

                                   {
     if (LIKELY(this->which_ == expected_detail::Which::eValue)) {
       return this->value_;
     }
     return static_cast<U&&>(dflt);
   }

template<class Value, class Error>

template<class U >

Value folly::Expected< Value, Error >::value_or ( U && dflt )

inline

Definition at line 1157 of file Expected.h.

                               {
     if (LIKELY(this->which_ == expected_detail::Which::eValue)) {
       return std::move(this->value_);
     }
     return static_cast<U&&>(dflt);
   }

template<class Value, class Error>

expected_detail::Which folly::Expected< Value, Error >::which ( ) const

inlineprivatenoexcept

Definition at line 1288 of file Expected.h.

                                               {
     return this->which_;
   }

Friends And Related Function Documentation

template<class Value, class Error>

template<class , class >

friend class Expected

friend

Definition at line 888 of file Expected.h.

template<class Value, class Error>

friend struct expected_detail::ExpectedHelper

friend

Definition at line 891 of file Expected.h.

template<class Value, class Error>

template<class , class , expected_detail::StorageType >

friend struct expected_detail::ExpectedStorage

friend

Definition at line 890 of file Expected.h.

template<class Value, class Error>

template<class Val , class Err >

std::enable_if<IsLessThanComparable<Val>::value, bool>::type operator<	(	const Expected< Val, Err > &	lhs,
		const Expected< Val, Err > &	rhs
	)

friend

template<class Value, class Error>

template<class Val , class Err >

std::enable_if<IsEqualityComparable<Val>::value, bool>::type operator==	(	const Expected< Val, Err > &	lhs,
		const Expected< Val, Err > &	rhs
	)

friend

Relational Operators

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

proxygen/folly/folly/Expected.h

Public Types

Public Member Functions

Private Types

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

template<class Value, class Error> class folly::Expected< Value, Error >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

template<class Value, class Error>
class folly::Expected< Value, Error >