Function.h File Reference

#include <functional>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include <folly/CppAttributes.h>
#include <folly/Portability.h>
#include <folly/Traits.h>
#include <folly/functional/Invoke.h>
#include <folly/lang/Exception.h>

Go to the source code of this file.

Classes
class	folly::Function< FunctionType >
union	folly::detail::function::Data
struct	folly::detail::function::NotFunction< T >
struct	folly::detail::function::NotFunction< Function< T > >
struct	folly::detail::function::CoerceTag
struct	folly::detail::function::FunctionTraits< FunctionType >
struct	folly::detail::function::FunctionTraits< ReturnType(Args...)>
class	folly::detail::function::FunctionTraits< ReturnType(Args...)>::SharedProxy
struct	folly::detail::function::FunctionTraits< ReturnType(Args...) const >
class	folly::detail::function::FunctionTraits< ReturnType(Args...) const >::SharedProxy
class	folly::Function< FunctionType >
class	folly::FunctionRef< FunctionType >
	A reference wrapper for callable objects. More...
class	folly::FunctionRef< ReturnType(Args...)>

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::detail
	folly::detail::function

Typedefs
template<typename Fun , typename = Fun*>
using	folly::detail::function::IsSmall = Conjunction< bool_constant<(sizeof(Fun)<=sizeof(Data::tiny))>, std::is_nothrow_move_constructible< Fun >>
using	folly::detail::function::SmallTag = std::true_type
using	folly::detail::function::HeapTag = std::false_type
template<typename T >
using	folly::detail::function::EnableIfNotFunction = typename std::enable_if< NotFunction< T >::value >::type
template<typename F , typename... Args>
using	folly::detail::function::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	folly::detail::function::SafeResultOf = decltype(static_cast< To >(std::declval< From >()))

Enumerations
enum	folly::detail::function::Op { folly::detail::function::Op::MOVE, folly::detail::function::Op::NUKE, folly::detail::function::Op::HEAP }

Functions
template<typename ReturnType , typename... Args>
Function< ReturnType(Args...) const >	folly::constCastFunction (Function< ReturnType(Args...)> &&) noexcept
template<typename T >
bool	folly::detail::function::isNullPtrFn (T *p)
template<typename T >
std::false_type	folly::detail::function::isNullPtrFn (T &&)
template<typename Fun >
bool	folly::detail::function::execSmall (Op o, Data *src, Data *dst)
template<typename Fun >
bool	folly::detail::function::execBig (Op o, Data *src, Data *dst)
template<typename FunctionType >
void	folly::swap (Function< FunctionType > &lhs, Function< FunctionType > &rhs) noexcept
template<typename FunctionType >
bool	folly::operator== (const Function< FunctionType > &fn, std::nullptr_t)
template<typename FunctionType >
bool	folly::operator== (std::nullptr_t, const Function< FunctionType > &fn)
template<typename FunctionType >
bool	folly::operator!= (const Function< FunctionType > &fn, std::nullptr_t)
template<typename FunctionType >
bool	folly::operator!= (std::nullptr_t, const Function< FunctionType > &fn)
template<typename ReturnType , typename... Args>
Function< ReturnType(Args...) const >	folly::constCastFunction (Function< ReturnType(Args...) const > &&that) noexcept