folly::exception_wrapper_detail Namespace Reference

Classes
struct	catch_fn

Typedefs
template<template< class > class T, class... As>
using	AllOf = StrictConjunction< T< As >... >
template<bool If, class T >
using	AddConstIf = _t< std::conditional< If, const T, T >>

Functions
template<class Ex >
Ex &&	dont_slice (Ex &&ex)
template<class Ex , class Fn >
catch_fn< Ex, Fn >	catch_ (Ex *, Fn fn)
template<class Fn >
Fn	catch_ (void const *, Fn fn)
template<class Fn , class A >
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN auto	fold (Fn &&, A &&a)
template<class Fn , class A , class B , class... Bs>
FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN auto	fold (Fn &&fn, A &&a, B &&b, Bs &&...bs)

Typedef Documentation

template<bool If, class T >

using folly::exception_wrapper_detail::AddConstIf = typedef _t<std::conditional<If, const T, T>>

Definition at line 65 of file ExceptionWrapper.h.

template<template< class > class T, class... As>

using folly::exception_wrapper_detail::AllOf = typedef StrictConjunction<T<As>...>

Definition at line 62 of file ExceptionWrapper.h.

Function Documentation

template<class Ex , class Fn >

catch_fn<Ex, Fn> folly::exception_wrapper_detail::catch_ ( Ex *  , Fn  fn  )

inline

Definition at line 627 of file ExceptionWrapper-inl.h.

References folly::gen::move.

Referenced by folly::exception_wrapper::with_exception_().

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

template<class Fn >

Fn folly::exception_wrapper_detail::catch_ ( void const *  , Fn  fn  )

inline

Definition at line 631 of file ExceptionWrapper-inl.h.

                                     {
  return fn;
}

template<class Ex >

Ex&& folly::exception_wrapper_detail::dont_slice

(

Ex &&

ex

)

Definition at line 345 of file ExceptionWrapper-inl.h.

References FOLLY_REQUIRES_DEF, and folly::value().

Referenced by folly::exception_wrapper::exception_wrapper().

                         {
  assert(typeid(ex) == typeid(_t<std::decay<Ex>>) ||
       !"Dynamic and static exception types don't match. Exception would "
        "be sliced when storing in exception_wrapper.");
  return std::forward<Ex>(ex);
}

template<class Fn , class A >

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN auto folly::exception_wrapper_detail::fold	(	Fn &&	,
		A &&	a
	)

Definition at line 68 of file ExceptionWrapper.h.

References a, B, FOLLY_ALWAYS_INLINE, and FOLLY_ATTR_VISIBILITY_HIDDEN.

Referenced by fold(), folly::gen::foldl(), and folly::exception_wrapper::handle_().

                                                                        {
  return static_cast<A&&>(a);
}

template<class Fn , class A , class B , class... Bs>

FOLLY_ALWAYS_INLINE FOLLY_ATTR_VISIBILITY_HIDDEN auto folly::exception_wrapper_detail::fold	(	Fn &&	fn,
		A &&	a,
		B &&	b,
		Bs &&...	bs
	)

Definition at line 74 of file ExceptionWrapper.h.

References a, b, and fold().

                                        {
  return fold(
      // This looks like a use of fn after a move of fn, but in reality, this is
      // just a cast and not a move. That's because regardless of which fold
      // overload is selected, fn gets bound to a &&. Had fold taken fn by value
      // there would indeed be a problem here.
      static_cast<Fn&&>(fn),
      static_cast<Fn&&>(fn)(static_cast<A&&>(a), static_cast<B&&>(b)),
      static_cast<Bs&&>(bs)...);
}