#include <cassert>
#include <cstddef>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include "absl/base/config.h"
#include "absl/base/internal/invoke.h"
#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"
#include "absl/utility/utility.h"

Include dependency graph for internal/any_invocable.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	absl::AnyInvocable< Sig >

struct	absl::internal_any_invocable::ConversionConstruct

class	absl::internal_any_invocable::CoreImpl< SigIsNoexcept, ReturnType, P >

class	absl::internal_any_invocable::CoreImpl< SigIsNoexcept, ReturnType, P >

struct	absl::internal_any_invocable::ForwardedParameter< T >

class	absl::internal_any_invocable::Impl< Sig >

struct	absl::internal_any_invocable::IsAnyInvocable< T >

struct	absl::internal_any_invocable::IsAnyInvocable< AnyInvocable< Sig > >

struct	absl::internal_any_invocable::CoreImpl< SigIsNoexcept, ReturnType, P >::IsCompatibleAnyInvocable< Other >

struct	absl::internal_any_invocable::CoreImpl< SigIsNoexcept, ReturnType, P >::IsCompatibleAnyInvocable< AnyInvocable< Sig > >

struct	absl::internal_any_invocable::IsInPlaceType< T >

struct	absl::internal_any_invocable::IsInPlaceType< absl::in_place_type_t< T > >

class	absl::internal_any_invocable::TrivialDeleter

struct	absl::internal_any_invocable::TypedConversionConstruct< QualDecayedTRef >

union	absl::internal_any_invocable::TypeErasedState

struct	absl::internal_any_invocable::UnwrapStdReferenceWrapperImpl< T >

struct	absl::internal_any_invocable::UnwrapStdReferenceWrapperImpl< std::reference_wrapper< T > >

Namespaces
	absl

	absl::internal_any_invocable

Macros
#define	ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals) ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)

#define	ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, noex)

#define	ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex) ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)

#define	ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false(inv_quals)

#define	ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true(inv_quals)

#define	ABSL_INTERNAL_NOEXCEPT_SPEC(noex)

Typedefs
template<class Sig , class F , class = absl::enable_if_t< !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
using	absl::internal_any_invocable::CanAssign = True< absl::enable_if_t< Impl< Sig >::template CallIsValid< F >::value >, absl::enable_if_t< Impl< Sig >::template CallIsNoexceptIfSigIsNoexcept< F >::value >, absl::enable_if_t< std::is_constructible< absl::decay_t< F >, F >::value > >

template<class Sig , class F >
using	absl::internal_any_invocable::CanAssignReferenceWrapper = True< absl::enable_if_t< Impl< Sig >::template CallIsValid< std::reference_wrapper< F > >::value >, absl::enable_if_t< Impl< Sig >::template CallIsNoexceptIfSigIsNoexcept< std::reference_wrapper< F > >::value > >

template<class Sig , class F , class = absl::enable_if_t< !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
using	absl::internal_any_invocable::CanConvert = True< absl::enable_if_t<!IsInPlaceType< RemoveCVRef< F > >::value >, absl::enable_if_t< Impl< Sig >::template CallIsValid< F >::value >, absl::enable_if_t< Impl< Sig >::template CallIsNoexceptIfSigIsNoexcept< F >::value >, absl::enable_if_t< std::is_constructible< absl::decay_t< F >, F >::value > >

template<class Sig , class F , class... Args>
using	absl::internal_any_invocable::CanEmplace = True< absl::enable_if_t< Impl< Sig >::template CallIsValid< F >::value >, absl::enable_if_t< Impl< Sig >::template CallIsNoexceptIfSigIsNoexcept< F >::value >, absl::enable_if_t< std::is_constructible< absl::decay_t< F >, Args... >::value > >

template<class T >
using	absl::internal_any_invocable::ForwardedParameterType = typename ForwardedParameter< T >::type

template<bool SigIsNoexcept, class ReturnType , class... P>
using	absl::internal_any_invocable::InvokerType = ReturnType(TypeErasedState *, ForwardedParameterType< P >...) ABSL_INTERNAL_NOEXCEPT_SPEC(SigIsNoexcept)

template<class T >
using	absl::internal_any_invocable::IsStoredLocally = std::integral_constant< bool, sizeof(T)<=kStorageSize &&alignof(T)<=kAlignment &&kAlignment % alignof(T)==0 &&std::is_nothrow_move_constructible< T >::value >

using	absl::internal_any_invocable::ManagerType = void(FunctionToCall, TypeErasedState , TypeErasedState ) ABSL_INTERNAL_NOEXCEPT_SPEC(true)

template<class T >
using	absl::internal_any_invocable::RemoveCVRef = typename std::remove_cv< typename std::remove_reference< T >::type >::type

template<class... T>
using	absl::internal_any_invocable::True = std::integral_constant< bool, sizeof(absl::void_t< T... > *) !=0 >

template<class T >
using	absl::internal_any_invocable::UnwrapStdReferenceWrapper = typename UnwrapStdReferenceWrapperImpl< T >::type

Enumerations
enum	absl::internal_any_invocable::FunctionToCall : bool { absl::internal_any_invocable::FunctionToCall::relocate_from_to, absl::internal_any_invocable::FunctionToCall::dispose }

enum	absl::internal_any_invocable::StorageProperty : std::size_t { absl::internal_any_invocable::kAlignment = alignof(std::max_align_t), absl::internal_any_invocable::kStorageSize = sizeof(void) 2 }

Functions
	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (, &&, &&)

	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (, &, &)

	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (,, &)

	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (const, &&, const &&)

	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (const, &, const &)

	absl::internal_any_invocable::ABSL_INTERNAL_ANY_INVOCABLE_IMPL (const,, const &)

void	absl::internal_any_invocable::EmptyManager (FunctionToCall, TypeErasedState , TypeErasedState ) noexcept

template<typename T >
T &&	absl::internal_any_invocable::ForwardImpl (std::false_type)

template<typename T >
T	absl::internal_any_invocable::ForwardImpl (std::true_type)

template<class ReturnType , class F , class... P, typename = absl::enable_if_t<std::is_void<ReturnType>::value>>
void	absl::internal_any_invocable::InvokeR (F &&f, P &&... args)

template<class ReturnType , class F , class... P, absl::enable_if_t<!std::is_void< ReturnType >::value, int > = 0>
ReturnType	absl::internal_any_invocable::InvokeR (F &&f, P &&... args)

template<bool NoExceptSrc, bool NoExceptDest, class... T>
constexpr bool	absl::internal_any_invocable::IsCompatibleConversion (CoreImpl< NoExceptSrc, T... > , CoreImpl< NoExceptDest, T... > )

constexpr bool	absl::internal_any_invocable::IsCompatibleConversion (void , void )

template<bool SigIsNoexcept, class ReturnType , class QualTRef , class... P>
ReturnType	absl::internal_any_invocable::LocalInvoker (TypeErasedState *const state, ForwardedParameterType< P >... args) noexcept(SigIsNoexcept)

template<class T >
void	absl::internal_any_invocable::LocalManagerNontrivial (FunctionToCall operation, TypeErasedState const from, TypeErasedState const to) noexcept

void	absl::internal_any_invocable::LocalManagerTrivial (FunctionToCall, TypeErasedState const from, TypeErasedState const to) noexcept

template<class T >
T &	absl::internal_any_invocable::ObjectInLocalStorage (TypeErasedState *const state)

template<bool SigIsNoexcept, class ReturnType , class QualTRef , class... P>
ReturnType	absl::internal_any_invocable::RemoteInvoker (TypeErasedState *const state, ForwardedParameterType< P >... args) noexcept(SigIsNoexcept)

template<class T >
void	absl::internal_any_invocable::RemoteManagerNontrivial (FunctionToCall operation, TypeErasedState const from, TypeErasedState const to) noexcept

void	absl::internal_any_invocable::RemoteManagerTrivial (FunctionToCall operation, TypeErasedState const from, TypeErasedState const to) noexcept

Macro Definition Documentation

◆ ABSL_INTERNAL_ANY_INVOCABLE_IMPL

#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL	(	cv,
		ref,
		inv_quals
	)	ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)

Definition at line 829 of file internal/any_invocable.h.

◆ ABSL_INTERNAL_ANY_INVOCABLE_IMPL_

#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL_	(	cv,
		ref,
		inv_quals,
		noex
	)

Definition at line 771 of file internal/any_invocable.h.

◆ ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT

#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT	(	inv_quals,
		noex
	)	ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)

Definition at line 734 of file internal/any_invocable.h.

◆ ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false

#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false ( inv_quals )

Definition at line 755 of file internal/any_invocable.h.

◆ ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true

#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true ( inv_quals )

Value:

  absl::enable_if_t<absl::disjunction<                                       \
      std::is_nothrow_invocable_r<                                           \
          ReturnType, UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
          P...>,                                                             \
      std::conjunction<                                                      \
          std::is_nothrow_invocable<                                         \
              UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, P...>,  \
          std::is_same<                                                      \
              ReturnType,                                                    \
              absl::base_internal::invoke_result_t<                          \
                  UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
                  P...>>>>::value>

Definition at line 741 of file internal/any_invocable.h.

◆ ABSL_INTERNAL_NOEXCEPT_SPEC

#define ABSL_INTERNAL_NOEXCEPT_SPEC ( noex )

Definition at line 81 of file internal/any_invocable.h.

Classes

Namespaces

Macros

Typedefs

Enumerations