folly::Try< T > Class Template Reference

#include <Try.h>

Public Types
typedef T	element_type

Public Member Functions
	Try () noexcept
	Try (const T &v) noexcept(std::is_nothrow_copy_constructible< T >::value)
	Try (T &&v) noexcept(std::is_nothrow_move_constructible< T >::value)
template<typename... Args>
	Try (in_place_t, Args &&...args) noexcept(std::is_nothrow_constructible< T, Args &&... >::value)
template<class T2 = T>
	Try (typename std::enable_if< std::is_same< Unit, T2 >::value, Try< void > const & >::type t) noexcept
	Implicit conversion from Try<void> to Try<Unit> More...
	Try (exception_wrapper e) noexcept
	Try (Try< T > &&t) noexcept(std::is_nothrow_move_constructible< T >::value)
Try &	operator= (Try< T > &&t) noexcept(std::is_nothrow_move_constructible< T >::value)
	Try (const Try &t) noexcept(std::is_nothrow_copy_constructible< T >::value)
Try &	operator= (const Try &t) noexcept(std::is_nothrow_copy_constructible< T >::value)
	~Try ()
template<typename... Args>
T &	emplace (Args &&...args) noexcept(std::is_nothrow_constructible< T, Args &&... >::value)
template<typename... Args>
exception_wrapper &	emplaceException (Args &&...args) noexcept(std::is_nothrow_constructible< exception_wrapper, Args &&... >::value)
T &	value ()&
T &&	value ()&&
const T &	value () const &
const T &&	value () const &&
void	throwIfFailed () const
const T &	operator* () const &
T &	operator* ()&
T &&	operator* ()&&
const T &&	operator* () const &&
const T *	operator-> () const
T *	operator-> ()
bool	hasValue () const
bool	hasException () const
template<class Ex >
bool	hasException () const
exception_wrapper &	exception ()&
exception_wrapper &&	exception ()&&
const exception_wrapper &	exception () const &
const exception_wrapper &&	exception () const &&
std::exception *	tryGetExceptionObject ()
std::exception const *	tryGetExceptionObject () const
template<class E >
E *	tryGetExceptionObject ()
template<class E >
E const *	tryGetExceptionObject () const
template<class Ex , class F >
bool	withException (F func)
template<class Ex , class F >
bool	withException (F func) const
template<class F >
bool	withException (F func)
template<class F >
bool	withException (F func) const
template<bool isTry, typename R >
std::enable_if< isTry, R >::type	get ()
template<bool isTry, typename R >
std::enable_if<!isTry, R >::type	get ()

Private Types
enum	Contains { Contains::VALUE, Contains::EXCEPTION, Contains::NOTHING }

Private Member Functions
void	destroy () noexcept

Private Attributes
Contains	contains_
union {
T   value_
exception_wrapper   e_
};

Detailed Description

template<class T>
class folly::Try< T >

Definition at line 51 of file Try.h.

Member Typedef Documentation

template<class T>

typedef T folly::Try< T >::element_type

Definition at line 66 of file Try.h.

Member Enumeration Documentation

template<class T>

enum folly::Try::Contains

strongprivate

Enumerator
VALUE
EXCEPTION
NOTHING

Definition at line 56 of file Try.h.

                      {
    VALUE,
    EXCEPTION,
    NOTHING,
  };

Constructor & Destructor Documentation

template<class T>

folly::Try< T >::Try ( )

inlinenoexcept

Definition at line 71 of file Try.h.

: contains_(Contains::NOTHING) {}

template<class T>

folly::Try< T >::Try ( const T &  v )

inlineexplicitnoexcept

Definition at line 78 of file Try.h.

      : contains_(Contains::VALUE), value_(v) {}

template<class T>

folly::Try< T >::Try ( T &&  v )

inlineexplicitnoexcept

Definition at line 87 of file Try.h.

      : contains_(Contains::VALUE), value_(std::move(v)) {}

template<class T>

template<typename... Args>

folly::Try< T >::Try ( in_place_t  , Args &&...  args  )

inlineexplicitnoexcept

Definition at line 91 of file Try.h.

      : contains_(Contains::VALUE), value_(static_cast<Args&&>(args)...) {}

template<class T >

template<class T2>

folly::Try< T >::Try ( typename std::enable_if< std::is_same< Unit, T2 >::value, Try< void > const & >::type  t )

noexcept

Implicit conversion from Try<void> to Try<Unit>

Definition at line 39 of file Try-inl.h.

References cpp.keywords::EXCEPTION, folly::pushmi::detail::t, and folly::T.

    : contains_(Contains::NOTHING) {
  if (t.hasValue()) {
    contains_ = Contains::VALUE;
    new (&value_) T();
  } else if (t.hasException()) {
    contains_ = Contains::EXCEPTION;
    new (&e_) exception_wrapper(t.exception());
  }
}

template<class T>

folly::Try< T >::Try ( exception_wrapper  e )

inlineexplicitnoexcept

Definition at line 106 of file Try.h.

      : contains_(Contains::EXCEPTION), e_(std::move(e)) {}

template<class T>

folly::Try< T >::Try ( Try< T > &&  t )

noexcept

Definition at line 28 of file Try-inl.h.

References cpp.keywords::EXCEPTION, folly::gen::move, folly::pushmi::detail::t, and folly::T.

    : contains_(t.contains_) {
  if (contains_ == Contains::VALUE) {
    new (&value_) T(std::move(t.value_));
  } else if (contains_ == Contains::EXCEPTION) {
    new (&e_) exception_wrapper(std::move(t.e_));
  }
}

template<class T>

folly::Try< T >::Try ( const Try< T > &  t )

noexcept

Definition at line 73 of file Try-inl.h.

References cpp.keywords::EXCEPTION, folly::pushmi::detail::t, folly::T, and value.

                                              {
  static_assert(
      std::is_copy_constructible<T>::value,
      "T must be copyable for Try<T> to be copyable");
  contains_ = t.contains_;
  if (contains_ == Contains::VALUE) {
    new (&value_) T(t.value_);
  } else if (contains_ == Contains::EXCEPTION) {
    new (&e_) exception_wrapper(t.e_);
  }
}

template<class T >

folly::Try< T >::~Try

(

)

Definition at line 111 of file Try-inl.h.

References testing::Args(), cpp.keywords::EXCEPTION, LIKELY, and UNLIKELY.

             {
  if (LIKELY(contains_ == Contains::VALUE)) {
    value_.~T();
  } else if (UNLIKELY(contains_ == Contains::EXCEPTION)) {
    e_.~exception_wrapper();
  }
}

Member Function Documentation

template<class T >

void folly::Try< T >::destroy ( )

privatenoexcept

Definition at line 176 of file Try-inl.h.

References cpp.keywords::EXCEPTION, folly::exchange(), LIKELY, NOTHING, and UNLIKELY.

                              {
  auto oldContains = folly::exchange(contains_, Contains::NOTHING);
  if (LIKELY(oldContains == Contains::VALUE)) {
    value_.~T();
  } else if (UNLIKELY(oldContains == Contains::EXCEPTION)) {
    e_.~exception_wrapper();
  }
}

template<typename T >

template<typename... Args>

T & folly::Try< T >::emplace ( Args &&...  args )

noexcept

Definition at line 121 of file Try-inl.h.

References testing::Args(), destroy(), and folly::T.

Referenced by TEST(), folly::tryEmplace(), and folly::tryEmplaceWith().

                                                    {
  this->destroy();
  new (&value_) T(static_cast<Args&&>(args)...);
  contains_ = Contains::VALUE;
  return value_;
}

template<typename T >

template<typename... Args>

exception_wrapper & folly::Try< T >::emplaceException ( Args &&...  args )

noexcept

Definition at line 131 of file Try-inl.h.

References destroy(), and cpp.keywords::EXCEPTION.

Referenced by folly::tryEmplace(), and folly::tryEmplaceWith().

                                                                    {
  this->destroy();
  new (&e_) exception_wrapper(static_cast<Args&&>(args)...);
  contains_ = Contains::EXCEPTION;
  return e_;
}

template<class T>

exception_wrapper& folly::Try< T >::exception ( )

inline

Definition at line 260 of file Try.h.

Referenced by folly::Future< T >::onTimeout(), and folly::futures::detail::retryingImpl().

                                   {
    if (!hasException()) {
      throw_exception<TryException>("Try does not contain an exception");
    }
    return e_;
  }

template<class T>

exception_wrapper&& folly::Try< T >::exception ( )

inline

Definition at line 267 of file Try.h.

                                     {
    if (!hasException()) {
      throw_exception<TryException>("Try does not contain an exception");
    }
    return std::move(e_);
  }

template<class T>

const exception_wrapper& folly::Try< T >::exception ( ) const

inline

Definition at line 274 of file Try.h.

                                              {
    if (!hasException()) {
      throw_exception<TryException>("Try does not contain an exception");
    }
    return e_;
  }

template<class T>

const exception_wrapper&& folly::Try< T >::exception ( ) const

inline

Definition at line 281 of file Try.h.

                                                {
    if (!hasException()) {
      throw_exception<TryException>("Try does not contain an exception");
    }
    return std::move(e_);
  }

template<class T>

template<bool isTry, typename R >

std::enable_if<isTry, R>::type folly::Try< T >::get ( )

inline

Definition at line 359 of file Try.h.

                                            {
    return std::forward<R>(*this);
  }

template<class T>

template<bool isTry, typename R >

std::enable_if<!isTry, R>::type folly::Try< T >::get ( )

inline

Definition at line 364 of file Try.h.

                                             {
    return std::forward<R>(value());
  }

template<class T>

bool folly::Try< T >::hasException ( ) const

inline

Definition at line 248 of file Try.h.

Referenced by folly::Try< void >::emplaceException(), folly::Future< T >::onTimeout(), TEST(), and folly::Try< void >::throwIfFailed().

                            {
    return contains_ == Contains::EXCEPTION;
  }

template<class T>

template<class Ex >

bool folly::Try< T >::hasException ( ) const

inline

Definition at line 256 of file Try.h.

                            {
    return hasException() && e_.is_compatible_with<Ex>();
  }

template<class T>

bool folly::Try< T >::hasValue ( ) const

inline

Definition at line 242 of file Try.h.

Referenced by folly::futures::detail::retryingImpl(), and TEST().

                        {
    return contains_ == Contains::VALUE;
  }

template<class T>

const T& folly::Try< T >::operator* ( ) const

inline

Definition at line 191 of file Try.h.

                              {
    return value();
  }

template<class T>

T& folly::Try< T >::operator* ( )

inline

Definition at line 199 of file Try.h.

                   {
    return value();
  }

template<class T>

T&& folly::Try< T >::operator* ( )

inline

Definition at line 208 of file Try.h.

                     {
    return std::move(value());
  }

template<class T>

const T&& folly::Try< T >::operator* ( ) const

inline

Definition at line 217 of file Try.h.

                                {
    return std::move(value());
  }

template<class T>

const T* folly::Try< T >::operator-> ( ) const

inline

Definition at line 227 of file Try.h.

                              {
    return &value();
  }

template<class T>

T* folly::Try< T >::operator-> ( )

inline

Definition at line 235 of file Try.h.

                  {
    return &value();
  }

template<class T>

Try< T > & folly::Try< T >::operator= ( Try< T > &&  t )

noexcept

Definition at line 53 of file Try-inl.h.

References destroy(), cpp.keywords::EXCEPTION, folly::gen::move, folly::pushmi::detail::t, and folly::T.

                                              {
  if (this == &t) {
    return *this;
  }

  destroy();

  if (t.contains_ == Contains::VALUE) {
    new (&value_) T(std::move(t.value_));
  } else if (t.contains_ == Contains::EXCEPTION) {
    new (&e_) exception_wrapper(std::move(t.e_));
  }

  contains_ = t.contains_;

  return *this;
}

template<class T>

Try< T > & folly::Try< T >::operator= ( const Try< T > &  t )

noexcept

Definition at line 87 of file Try-inl.h.

References destroy(), cpp.keywords::EXCEPTION, folly::pushmi::detail::t, folly::T, and value.

                                              {
  static_assert(
      std::is_copy_constructible<T>::value,
      "T must be copyable for Try<T> to be copyable");

  if (this == &t) {
    return *this;
  }

  destroy();

  if (t.contains_ == Contains::VALUE) {
    new (&value_) T(t.value_);
  } else if (t.contains_ == Contains::EXCEPTION) {
    new (&e_) exception_wrapper(t.e_);
  }

  contains_ = t.contains_;

  return *this;
}

template<class T >

void folly::Try< T >::throwIfFailed

(

)

const

Definition at line 164 of file Try-inl.h.

References cpp.keywords::EXCEPTION.

                                 {
  switch (contains_) {
    case Contains::VALUE:
      return;
    case Contains::EXCEPTION:
      e_.throw_exception();
    default:
      throw_exception<UsingUninitializedTry>();
  }
}

template<class T>

std::exception* folly::Try< T >::tryGetExceptionObject ( )

inline

Definition at line 292 of file Try.h.

Referenced by TEST().

                                        {
    return hasException() ? e_.get_exception() : nullptr;
  }

template<class T>

std::exception const* folly::Try< T >::tryGetExceptionObject ( ) const

inline

Definition at line 295 of file Try.h.

                                                    {
    return hasException() ? e_.get_exception() : nullptr;
  }

template<class T>

template<class E >

E* folly::Try< T >::tryGetExceptionObject ( )

inline

Definition at line 305 of file Try.h.

                             {
    return hasException() ? e_.get_exception<E>() : nullptr;
  }

template<class T>

template<class E >

E const* folly::Try< T >::tryGetExceptionObject ( ) const

inline

Definition at line 309 of file Try.h.

                                         {
    return hasException() ? e_.get_exception<E>() : nullptr;
  }

template<class T >

T && folly::Try< T >::value

(

)

Definition at line 140 of file Try-inl.h.

References folly::gen::move, and folly::T.

Referenced by folly::futures::detail::TryEquals< T >::equals(), folly::makeTryWith(), folly::futures::detail::retryingImpl(), TEST(), folly::Try< void >::throwIfFailed(), folly::tryEmplaceWith(), and folly::Try< T >::value().

                   {
  throwIfFailed();
  return value_;
}

template<class T>

T&& folly::Try< T >::value

(

)

template<class T >

const T && folly::Try< T >::value

(

)

const

Definition at line 152 of file Try-inl.h.

References folly::gen::move, folly::T, and folly::Try< T >::value().

                              {
  throwIfFailed();
  return value_;
}

template<class T>

const T&& folly::Try< T >::value

(

)

const

template<class T>

template<class Ex , class F >

bool folly::Try< T >::withException ( F  func )

inline

Definition at line 321 of file Try.h.

                             {
    if (!hasException()) {
      return false;
    }
    return e_.with_exception<Ex>(std::move(func));
  }

template<class T>

template<class Ex , class F >

bool folly::Try< T >::withException ( F  func ) const

inline

Definition at line 328 of file Try.h.

                                   {
    if (!hasException()) {
      return false;
    }
    return e_.with_exception<Ex>(std::move(func));
  }

template<class T>

template<class F >

bool folly::Try< T >::withException ( F  func )

inline

Definition at line 344 of file Try.h.

                             {
    if (!hasException()) {
      return false;
    }
    return e_.with_exception(std::move(func));
  }

template<class T>

template<class F >

bool folly::Try< T >::withException ( F  func ) const

inline

Definition at line 351 of file Try.h.

                                   {
    if (!hasException()) {
      return false;
    }
    return e_.with_exception(std::move(func));
  }

Member Data Documentation

union { ... }

template<class T>

Contains folly::Try< T >::contains_

private

Definition at line 371 of file Try.h.

template<class T>

exception_wrapper folly::Try< T >::e_

Definition at line 374 of file Try.h.

Referenced by folly::Try< void >::emplaceException(), and folly::Try< void >::throwIfFailed().

template<class T>

T folly::Try< T >::value_

Definition at line 373 of file Try.h.

---

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

• proxygen/folly/folly/Try.h
• proxygen/folly/folly/Try-inl.h