etl/docs/callbacks/inplace_function.md

title	weight
inplace_function	1

---

Header: inplace_function.h

Support: 20.45.0

Similar to: std::function

A small, in-place function wrapper that stores callable objects inside a fixed-size buffer (no dynamic allocation). It supports free functions, member functions, functors, and lambdas, with both runtime and compile-time bindings.

template <typename TSignature,
          size_t Object_Size      = ETL_DEFAULT_INPLACE_FUNCTION_SIE,
          size_t Object_Alignment = ETL_DEFAULT_INPLACE_FUNCTION_ALIGNMENT>
class inplace_function;

The defaults are defined as follows:-

#if !defined(ETL_DEFAULT_INPLACE_FUNCTION_SIE)
  #define ETL_DEFAULT_INPLACE_FUNCTION_SIE 32
#endif

#if !defined(ETL_DEFAULT_INPLACE_FUNCTION_ALIGNMENT)
  #define ETL_DEFAULT_INPLACE_FUNCTION_ALIGNMENT alignof(void*)
#endif

Set your own definitions in etl_profile.h if you require different defaults.

Template Parameters

TSignature

The function signature. e.g. int(char, float)

Object_Size

Size of the internal storage buffer. Defaults to ETL_DEFAULT_INPLACE_FUNCTION_SIZE.

Object_Alignment

Alignment of the internal storage buffer. Defaults to ETL_DEFAULT_INPLACE_FUNCTION_ALIGNMENT.

Exceptions

etl::inplace_function_exception

Base exception.

etl::inplace_function_uninitialized

Thrown (via ETL_ASSERT) when invoked without a target.

Member Types

function_type

return_type

argument_types

Constructors

Default constructor.

Copy/move constructors.

Construction from a free function pointer.

Construction from an object + member function pointer (const or non-const).

Construction from a lambda/functor (const or non-const).

Assignment

Copy/move assignment.

Assignment from nullptr clears the target.

Assignment from function pointer.

Assignment from lambda/functor.

Invocation

operator()

Invokes the bound callable and asserts if uninitialised.

call_if(...)

For void return bool indicating whether it executed. For non-void returns etl::optional.

call_or(...)

Invokes the target or a fallback callable.

Observers

bool is_valid() const

Returns true if there is a valid callable.

explicit operator bool() const

Returns the result of is_valid()

Modifiers

void clear()

Clears any stored callable.

void swap(inplace_function& other)

Swaps with another inplace_function.

Storage Introspection

static constexpr size_t size()

Returns the size of the internal storage.

static constexpr size_t alignment()

Returns the alignment of the internal storage.

Compile-Time Binding (No Payload)

Free function

template <TReturn(*Function)(TArgs...)>
void set()

Sets the callable to Function.

template <TReturn(*Function)(TArgs...)>
inplace_function<TReturn(TArgs...),
                         Object_Size,
                         Object_Alignment> create()

Creates an etl::inplace_function using Function.

Member function + instance (external linkage)

template <typename TObject, TReturn(TObject::*Method)(TArgs...), TObject& Instance>
set<TObject, &TMethod, Instance>()

Sets the callable to the member function Method for the object Instance.

create<TObject, &TMethod, Instance>()

Callable object + instance (operator())

set<T, Instance>()

create<T, Instance>()

Helper Aliases

etl::inplace_function_for<TSignature, TStorage>

etl::inplace_function_for_any<TSignature, T0, ...>

Helper Factories

make_inplace_function(function_ptr)

make_inplace_function(obj, &Type::Method)

make_inplace_function(lambda_or_functor)

make_inplace_function<TSignature>(function_like)

C++17-only overloads also exist for compile-time binding.

Example

#include "etl/inplace_function.h"

int add(int a, int b) { return a + b; }

struct Accumulator
{
  int base = 0;

  int add_to(int v) { return base + v; }
};

void example()
{
  etl::inplace_function<int(int, int)> f(add);
  int sum = f(1, 2);

  Accumulator acc{ 10 };

  etl::inplace_function<int(int)> g(&Accumulator::add_to, acc);

  int result = g(5);
}

Notes

If the callable object is larger than Object_Size or requires stricter alignment than Object_Alignment, compilation fails with a static_assert.

operator() asserts when called without a target; use call_if or call_or to avoid this.

Prefer inplace_function_for, inplace_function_for_any or make_inplace_function to deduce storage sizes safely.