folly::detail::function Namespace Reference

Classes
struct	CoerceTag
union	Data
struct	FunctionTraits
struct	FunctionTraits< ReturnType(Args...) const >
struct	FunctionTraits< ReturnType(Args...)>
struct	NotFunction
struct	NotFunction< Function< T > >

Typedefs
template<typename Fun , typename = Fun*>
using	IsSmall = Conjunction< bool_constant<(sizeof(Fun)<=sizeof(Data::tiny))>, std::is_nothrow_move_constructible< Fun >>
using	SmallTag = std::true_type
using	HeapTag = std::false_type
template<typename T >
using	EnableIfNotFunction = typename std::enable_if< NotFunction< T >::value >::type
template<typename F , typename... Args>
using	CallableResult = decltype(std::declval< F >()(std::declval< Args >()...))
template<typename From , typename To , typename = typename std::enable_if< !std::is_reference<To>::value || std::is_reference<From>::value>::type>
using	SafeResultOf = decltype(static_cast< To >(std::declval< From >()))

Enumerations
enum	Op { Op::MOVE, Op::NUKE, Op::HEAP }

Functions
template<typename T >
bool	isNullPtrFn (T *p)
template<typename T >
std::false_type	isNullPtrFn (T &&)
template<typename Fun >
bool	execSmall (Op o, Data *src, Data *dst)
template<typename Fun >
bool	execBig (Op o, Data *src, Data *dst)

Typedef Documentation

template<typename F , typename... Args>

using folly::detail::function::CallableResult = typedef decltype(std::declval<F>()(std::declval<Args>()...))

Definition at line 286 of file Function.h.

template<typename T >

using folly::detail::function::EnableIfNotFunction = typedef typename std::enable_if<NotFunction<T>::value>::type

Definition at line 272 of file Function.h.

using folly::detail::function::HeapTag = typedef std::false_type

Definition at line 263 of file Function.h.

template<typename Fun , typename = Fun*>

using folly::detail::function::IsSmall = typedef Conjunction< bool_constant<(sizeof(Fun) <= sizeof(Data::tiny))>, std::is_nothrow_move_constructible<Fun>>

Definition at line 261 of file Function.h.

template<typename From , typename To , typename = typename std::enable_if< !std::is_reference<To>::value || std::is_reference<From>::value>::type>

using folly::detail::function::SafeResultOf = typedef decltype(static_cast<To>(std::declval<From>()))

Definition at line 293 of file Function.h.

using folly::detail::function::SmallTag = typedef std::true_type

Definition at line 262 of file Function.h.

Enumeration Type Documentation

enum folly::detail::function::Op

strong

Enumerator
MOVE
NUKE
HEAP

Definition at line 250 of file Function.h.

{ MOVE, NUKE, HEAP };

Function Documentation

template<typename Fun >

bool folly::detail::function::execBig	(	Op	o,
		Data *	src,
		Data *	dst
	)

Definition at line 499 of file Function.h.

References folly::detail::function::Data::big, HEAP, MOVE, and NUKE.

                                         {
  switch (o) {
    case Op::MOVE:
      dst->big = src->big;
      src->big = nullptr;
      break;
    case Op::NUKE:
      delete static_cast<Fun*>(src->big);
      break;
    case Op::HEAP:
      break;
  }
  return true;
}

template<typename Fun >

bool folly::detail::function::execSmall	(	Op	o,
		Data *	src,
		Data *	dst
	)

Definition at line 483 of file Function.h.

References FOLLY_FALLTHROUGH, HEAP, MOVE, folly::gen::move, NUKE, and folly::detail::function::Data::tiny.

                                           {
  switch (o) {
    case Op::MOVE:
      ::new (static_cast<void*>(&dst->tiny))
          Fun(std::move(*static_cast<Fun*>(static_cast<void*>(&src->tiny))));
      FOLLY_FALLTHROUGH;
    case Op::NUKE:
      static_cast<Fun*>(static_cast<void*>(&src->tiny))->~Fun();
      break;
    case Op::HEAP:
      break;
  }
  return false;
}

template<typename T >

bool folly::detail::function::isNullPtrFn

(

T *

p

)

Definition at line 277 of file Function.h.

Referenced by folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>::Function().

                       {
  return p == nullptr;
}

template<typename T >

std::false_type folly::detail::function::isNullPtrFn

(

T &&

)

Definition at line 281 of file Function.h.

References testing::Args().

                               {
  return {};
}