internal_any_invocable

Enumerations

enum StorageProperty

Name	Value
kAlignment	alignof(std::max_align_t)
kStorageSize	sizeof(void) 2

Constants relating to the small-object-storage for AnyInvocable

Defined at line 93 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

enum FunctionToCall

Name	Value
relocate_from_to	0
dispose	1

A discriminator when calling the "manager" function that describes operation

type-erased operation should be invoked.

"relocate_from_to" specifies that the manager should perform a move.

"dispose" specifies that the manager should perform a destroy.

Defined at line 188 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

Records

Functions

```
template <typename T>
```
```
T ForwardImpl (std::true_type )
```
/////////////////////////////////////////////////////////////////////////////

A metafunction that takes a "T" corresponding to a parameter type of the

user's specified function type, and yields the parameter type to use for the

type-erased invoker. In order to prevent observable moves, this must be

either a reference or, if the type is trivial, the original parameter type

itself. Since the parameter type may be incomplete at the point that this

metafunction is used, we can only do this optimization for scalar types

rather than for any trivial type.

template <typename T>

T && ForwardImpl (std::false_type )

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

An implementation of the C++ standard INVOKE

<R

> pseudo-macro, operation is

equivalent to std::invoke except that it forces an implicit conversion to the

specified return type. If "R" is void, the function is executed and the

return value is simply ignored.

Defined at line 131 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

template <class ReturnType, class F, class... P, absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>

ReturnType InvokeR (F && f, P &&... args)

Defined at line 137 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

template <class ReturnType, class F, class... P, absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>

ReturnType InvokeR (F && f, P &&... args)

Defined at line 137 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

```
template <class T>
```
```
T & ObjectInLocalStorage (TypeErasedState *const state)
```
A typed accessor for the object in `TypeErasedState` storage

Defined at line 206 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
void EmptyManager (FunctionToCall , TypeErasedState * , TypeErasedState * )
```
The manager that is used when AnyInvocable is empty

Defined at line 244 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
void LocalManagerTrivial (FunctionToCall , TypeErasedState *const from, TypeErasedState *const to)
```
The manager that is used when a target function is in local storage and is

a trivially copyable type.

Defined at line 250 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
template <class T>
```
```
void LocalManagerNontrivial (FunctionToCall operation, TypeErasedState *const from, TypeErasedState *const to)
```
The manager that is used when a target function is in local storage and is

not a trivially copyable type.

Defined at line 275 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
```
```
ReturnType LocalInvoker (TypeErasedState *const state, ForwardedParameterType<P>... args)
```
The invoker that is used when a target function is in local storage

Note: QualTRef here is the target function type along with cv and reference

qualifiers that must be used when calling the function.

Defined at line 301 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
void RemoteManagerTrivial (FunctionToCall operation, TypeErasedState *const from, TypeErasedState *const to)
```
The manager that is used when a target function is in remote storage and it

has a trivial destructor

Defined at line 316 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h
```
template <class T>
```
```
void RemoteManagerNontrivial (FunctionToCall operation, TypeErasedState *const from, TypeErasedState *const to)
```
The manager that is used when a target function is in remote storage and the

destructor of the type is not trivial

Defined at line 338 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>

ReturnType RemoteInvoker (TypeErasedState *const state, ForwardedParameterType<P>... args)

The invoker that is used when a target function is in remote storage

Defined at line 359 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

```
bool IsCompatibleConversion (void * , void * )
```
Defined at line 427 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h

template <bool NoExceptSrcbool NoExceptDestclass... T>

bool IsCompatibleConversion (CoreImpl<NoExceptSrc, T...> * CoreImpl<NoExceptDest, T...> * )

Defined at line 429 of file ../../third_party/abseil-cpp/absl/functional/internal/any_invocable.h