Forum - Recent Threads

C++ callbacks and templates

Jan Cumps — Sat, 15 Jun 2024 10:50:00 GMT

I'm experimenting: can I use a method of a particular object as a callback? This can be used in typical callback situations, e.g.: in a UART driver. But also in interrupt handlers.

lightweight: small runtime cost, low firmware hit. Can be used for tiny embedded systems.
reusable: don't assume parameters and types for the handler, when writing this little framework -> C++ templates
hip -> object oriented, modern C++ constructs
type safe -> again C++ templates
allow a classic C function, a lambda, a static class method or an object method as handler

example: Raspberry Pico blinky using this design

#include <new>
#include <stdio.h>
#include "pico/stdlib.h"

import callbackmanager;

const uint32_t delay_ms = 250;

callbackmanager::Callback<void> cb;

int main() {
gpio_init(PICO_DEFAULT_LED_PIN);
gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);
cb.set([]() {
static bool state = false;
gpio_put(PICO_DEFAULT_LED_PIN, state = !state);
});

while (true) {
cb();
sleep_ms(delay_ms);
}
}

project: [View:/cfs-file/__key/communityserver-discussions-components-files/126/2133.pico_5F00_callback_5F00_blink.zip:640:360]

Callback template class

The template callback class. This is in essence the whole mechanism. A generic class that allows you to register and call event handler functions, lambda's and methods.

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:2793c371-9a96-43d1-8524-51f6e47409cf:type=c_cpp&text=%23include%20%3Cfunctional%3E%0A%0A%2F%2F%20concept%20guards%20what%20types%20of%20return%20values%20we%20can%20handle%0Atemplate%3Ctypename%20R%3E%0Aconcept%20Callbackable%20%3D%20%0A%09std%3A%3Ais_void%3CR%3E%3A%3Avalue%20%7C%7C%0A%09std%3A%3Ais_arithmetic_v%3CR%3E%20%7C%7C%0A%09std%3A%3Ais_class_v%3CR%3E%3B%0A%09%0Atemplate%20%3CCallbackable%20R%2C%20typename...%20Args%3E%0Aclass%20Callback%20%7B%0A%09using%20callbackfunction_t%20%3D%20std%3A%3Afunction%3CR%28Args...%29%3E%3B%09%0Apublic%3A%0A%09Callback%28%29%20%3A%20callback_%28nullptr%29%2C%20isSet%28false%29%7B%7D%0A%0A%09inline%20void%20set%28callbackfunction_t%20callback%29%20%7B%0A%09%20%20%20%20callback_%20%3D%20callback%3B%0A%09%09isSet%20%3D%20true%3B%0A%09%7D%0A%0A%09inline%20void%20unset%28%29%20%7B%0A%09%09callback_%20%3D%20nullptr%3B%0A%09%09isSet%20%3D%20false%3B%0A%09%7D%0A%0A%09inline%20bool%20is_set%28%29%20%7B%0A%09%09return%20isSet%3B%09%09%0A%09%7D%0A%0A%09%2F%2A%0A%09%20%2A%20R%20can%20be%20an%20arithmetic%20type%2C%20an%20object%2C%20or%20void%0A%09%20%2A%2F%0A%09inline%20R%20operator%28%29%28Args...%20args%29%20%7B%0A%09%09if%20constexpr%20%28std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%20%20%2F%2F%20void%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0A%09%09%09%09return%3B%0A%09%09%09%7D%20else%20%7B%0A%09%09%09%09%28callback_%29%28args...%29%3B%0A%09%09%09%7D%0A%09%09%7D%20else%20if%20constexpr%20%28std%3A%3Ais_class%3CR%3E%3A%3Avalue%29%20%7B%20%2F%2F%20object%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0A%09%09%09%09return%20R%28%29%3B%0A%09%09%09%7D%20else%20%7B%0A%09%09%09%09return%20%28callback_%29%28args...%29%3B%0A%09%09%09%7D%0A%09%09%7D%20else%20%7B%20%2F%2F%20not%20void%20nor%20object%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0A%09%09%09%09return%200%3B%20%2F%2F%20R%20can%20only%20be%20a%20arithmetic%20type.%200%20should%20work%20as%20default.%0A%09%09%09%7D%20else%20%7B%0A%09%09%09%09return%20%28callback_%29%28args...%29%3B%0A%09%09%09%7D%0A%09%09%7D%0A%0A%09%7D%0A%09%0Aprivate%3A%0A%09callbackfunction_t%20callback_%3B%0A%09bool%20isSet%3B%0A%7D%3B]

This generic class allows for handlers that pass any amount of parameters. No assumption of the types.

When we use the class in our code, we 'll tell it what the parameters are, and their type. For this blog, I am going to pass it 2 integers. The return value is also an integer.

Callback<int, int, int> cb;

In the declaration above, the first int is the return value type, the 2 others are parameter 1 and 2. Once you write this code, the object cb will only accept handler methods that take two integers as parameter, and return an integer.

Example of class that will handle the callback

This could be a gio class (blinky a led when an interrupt occurred?), a GUIwidget, or a business object. Typical guidelines apply: a handler should be swift. In particular if it's an interrupt handler.

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:4b853d3e-7d6c-4fcb-a69e-3482825079e3:type=c_cpp&text=class%20MyClass%20%7B%0D%0Apublic%3A%0D%0A%20%20%20%20%20%20int%20handler%28int%20num1%2C%20int%20num2%29%20%7B%0D%0A%20%20%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0D%0A%20%20%20%20%20%20%7D%0D%0A%7D%3B]

The example does not do a lot today. It just sums up the two integers passed. But as a POC this will do.

Actual code using the two

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:3efa4a2c-b3c4-4a28-a2a4-d1d55783f960:type=c_cpp&text=%23include%20%3Ccstdio%3E%0A%0Aint%20main%28%29%0A%7B%0A%20%20%20%20MyClass%20myClass%3B%0A%0A%20%20%20%20Callback%3Cint%2C%20int%2C%20int%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20capture%20myClass%20and%20call%20the%20member%20method%0A%20%20%20%20cb.set%28%5B%26myClass%5D%28int%20num1%2C%20int%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20myClass.handler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20a%20%3D%204%3B%0A%20%20%20%20int%20b%20%3D%205%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%20%2F%2F%20We%20might%20be%20on%20an%20embedded%20system%2C%20use%20printf%28%29%20and%20not%20std%3A%3Acout%0A%7D]

Why use a lambda to pair the handler and Callback ?

In the code, I did not learn the MyClass how to register itself. And the Callback doesn't know anything about who or what it 'll call. These classes (and their objects) are unaware of each other. Loose coupling.

Callback<int, int, int> cb;

cb.set([&myClass](int num1, int num2) -> int { return myClass.handler(num1, num2); });

In the application logic, I tie the two together. The lambda function code (the anonymous function, starting with the [, and ending with the } above), is used as the vehicle to hold the code that the Callback object will execute when needed.

The lambda function could as well be a straigtforward piece of code, not related to any object:

Callback<int, int, int> cb;

cb.set([](int num1, int num2) -> int {
return num1 + num2;
});

Or we could pass completely different executable code. As long as the lambda matches the signature given when instantiating the Callback class.

In an embedded system,

myClass would be one of your application objects.
cb could be part of a driver, or the HAL layer
cb.set() would be called by you, to register the handler
cb.call() would be done by the driver, or HAL ISR, when it wants to notify you (call your callback handler)

In the case of this example, it will execute myClass.handler(). If you 'd have many MyClass objects, it would call the exact one that's registered in with set().

Example use of the callback class in an embedded application

Anything special?

This approach allows to write a reusable callback system. It is type safe. But it does not assume what the type is of the object it 'll call the handler off. (Or if it's actually an object).
It's a small amount of code, that performs a function that you regularly need in an embedded or event driven design.

What does type-safe mean in this context?

If your interrupt handler assumes a function that passes 2 integers, and you pass it a callback function that has different parameters,
you get a compile time error. Your code will not build, because the handler is not compatible.

And you get all of that, without having to specify the number of variables, and their types, in the Callback class code. We get a reusable class. Type safe. Without the need to foresee all possible combinations.

this library now also works for Arduino (tested with IDE2, and an Arduino MKT GSM 1400)

For Arduino, you can download callbackmanager.h to your computer, then use Sketch -> Add File ... to get the callbackmanager included to your project.
Add this line to your sketch:

#include "callbackmanager.h"

I added a sketch to test the callback manager to this gist: test_arduino.ino

Arduinos that use the gcc-avg toolchain are not supported (UNO, Mega, the original basic Nano)

shortcuts:

I assume fixed return value type. A richer implementation can use template for that too, and should allow void. edit: this works
I pass arguments by value. A better design would also allow pass by reference. And to pass const references. edit: this works
should I use a shared pointer, so that I can never call the handler of an object that no longer exists? (solved by alternative: provide an unset() method). edit: the class no longer uses pointers
it only allows to call one handler. Good for ISR use. But in an event driven design, you may want to register more handlers. I prefer just one handler. simple scope, simple responsibility.

Inspiration:

I started from this example by Geoffrey Hunter.
mbed's Callback class, although I didn't use any of the code
cplusplus' tutorial for std::function, to validate if it works for static class member, object member, classic C function and lambda function.

Code is available on github. Additional assets available on Gist.

CMakeLists.txt to build an example program:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:ca5e5f4f-89fe-4045-91d5-5cfb53ff9704:type=text&text=cmake_minimum_required%28VERSION%203.28%29%0A%0Aproject%28callbackmanager%20C%20CXX%20ASM%29%0A%0A%23%20GoogleTest%20requires%20at%20least%20C%2B%2B14%0Aset%28CMAKE_CXX_STANDARD%2026%29%0Aset%28CMAKE_CXX_STANDARD_REQUIRED%20ON%29%0Aset%28CMAKE_CXX_FLAGS%20%22%24%7BCMAKE_CXX_FLAGS%7D%20-fmodules-ts%20-fcommon%22%29%0A%0Aadd_executable%28%24%7BCMAKE_PROJECT_NAME%7D%29%0Atarget_sources%28%24%7BCMAKE_PROJECT_NAME%7D%0A%20%20%20%20%20%20%20%20PUBLIC%0A%20%20%20%20%20%20%20%20%24%7BCMAKE_CURRENT_SOURCE_DIR%7D%2Fexample%2Fcallback_examples.cpp%0A%29%0Atarget_sources%28%24%7BCMAKE_PROJECT_NAME%7D%0A%20%20%20%20%20%20%20%20PUBLIC%0A%20%20%20%20%20%20%20%20FILE_SET%20cxx_modules%20TYPE%20CXX_MODULES%20FILES%0A%20%20%20%20%20%20%20%20%24%7BCMAKE_CURRENT_SOURCE_DIR%7D%2Fcallbackmanager.cpp%0A%29%0A%0Atarget_link_libraries%28%20%24%7BCMAKE_PROJECT_NAME%7D%0A%29]

I test this code in [mention:5b356e0658814266b1c94f99fba9084c:46448885d0e64133bbfbf0cd7b0fd6f7]
edit 20250208: I converted it to a c++ module: [mention:4bba44c64c404a9998ef8303509171f3:f7d226abd59f475c9d224a79e3f0ec07]

RE: C++ callbacks and templates

Jan Cumps — Thu, 13 Mar 2025 20:41:48 GMT

Is this expensive?

The callback manager class consumes 20 bytes

The code that's executed does not change. If you have to perform the logic, the code has to be there, regardless if you use the callback.

There is a price of using std::function. Not flyweight but still light. A few calls between invoking the callback and executing the actual callback handler. Not impacting on an ARM controller, even the tiny ones.

If you use a real time system and you worry about using this in a tight loop: the clock ticks to invoke the handler are deterministic and hard. Your profiler can check if your code can perform in the available timeslot.

Using one of the smaller ATMELs? Performance impact is not relevant. There's no C toolchain for those controllers that supports this design.

RE: C++ callbacks and templates

Jan Cumps — Thu, 13 Mar 2025 17:39:44 GMT

example: Raspberry Pico Blinky using this design

#include <new>
#include <stdio.h>
#include "pico/stdlib.h"

import callbackmanager;

const uint32_t delay_ms = 250;
callbackmanager::Callback<void> cb;

int main() {
gpio_init(PICO_DEFAULT_LED_PIN);
gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);
cb.set([]() {
static bool state = false;
gpio_put(PICO_DEFAULT_LED_PIN, state = !state);
});

while (true) {
cb();
sleep_ms(delay_ms);
}
}

vscode project: community.element14.com/.../pico_5F00_callback_5F00_blink.zip

RE: C++ callbacks and templates

Jan Cumps — Fri, 07 Mar 2025 15:38:05 GMT

Just checked it on an Arduino MKR 1400, with some hardware manipulation. The callbacks do the job.

Until your Arduino Board Manager ships with GCC 10 or later, comment this line in the callbackmanager class definition:

// requires std::is_void<R>::value || std::is_arithmetic_v<R>

This isn't supported in the (at the time of writing) version that ships with the MKR boards. The code isn't needed to operate. It's a compile time construct that gives a clear error when you try to set a callback handler that isn't supported*.

Without this line, you 'll get a compile error too, but it will throw that error at a location where it's not very clear what's wrong.

So: result is the same: compiler throws an error as it should. But that extra line makes it easier to find what's wrong and remediate.
* the callback manager supports handlers that return a bool, any type of number, most objects that have a default creator and have "return-me capability, or void.

RE: C++ callbacks and templates

Jan Cumps — Sun, 01 Sep 2024 17:46:43 GMT

I used the mechanism in the GPS library that I designed for a ST Micro Teseo GPS IC.

It's used to call a device specific read, write and reset function, in a device independent library.

RE: C++ callbacks and templates

Jan Cumps — Mon, 22 Jul 2024 12:57:35 GMT

this library now also works for Arduino (tested with IDE2, and an Arduino MKT GSM 1400)

For Arduino, you can download callbackmanager.h to your computer, then use Sketch -> Add File ... to get the callbackmanager included to your project.
Add this line to your sketch:

#include "callbackmanager.h"

I added a sketch to test the callback manager as a GitHub GIST: test_arduino.ino

I expect this will work on the newer ADO boards. The AVR compiler for Arduino UNO / Nano (both use avr-gcc) does not support this. But the Nano IoT (uses arm-gcc) does.

A Zero and the MKR family work.

RE: C++ callbacks and templates

Jan Cumps — Fri, 19 Jul 2024 18:55:22 GMT

latest version on github gist allows compilation with lower version GCC (including the Renesas and Arduino toolchains).

There is no difference at runtime. You 'll only get a little more cryptic error if you use unsupported template types:
an error when the compiler detects that the code can't handle your type, instead of an error right at the declaration where you define what parameter types you want to use.

RE: GitHub: automate Raspberry Pico project build verification with GitHub Actions

Jan Cumps — Mon, 15 Jul 2024 11:57:09 GMT

cstanton , can you delete this forum post? It's now GitHub: automate Raspberry Pico project build verification with GitHub Actions

GitHub: automate Raspberry Pico project build verification with GitHub Actions

Jan Cumps — Mon, 15 Jul 2024 09:44:56 GMT

Moved to [mention:fd8811585d4a425bb3b0816cf2887d20:f7d226abd59f475c9d224a79e3f0ec07]

You can Make GitHub build your project. I'm using an Action to check out branches and build them, when a pull request is submitted.
I adapted an existing flow from the Raspberry organisation. Here's what it does

check out the branch that's the source for the pull request
check out Pico-SDK, the current development branch
install CMake
install the arm bare metal GNU toolchain
build the SDK
build the project
react on pull request creation on the main and develop branch.
make successful compilation a mandatory check for the pull request.

If the build fails, the pull request fails. That's what I try to achieve in this exercise:

developers can check in non-working in feature branches.
once ready to ask merging with one of the two protected branches (develop or main), code should meet quality requirements and should build.
That's the moment that you deem your work done, and should be ready for a code review.
If your code breaks the build at this point, you impact others - and maybe the production release. It's a fail.
Code reviewers don't have to spend time validating non-funcioning code.

The script I'm using is based on the Raspberrry MacOS build for Pico. I adapted it for Linux.

Script source of build.yml:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:ee420520-335b-415c-9649-8b8889964dd2:type=text&text=name%3A%20Build%20on%20ubuntu%20against%20pico-sdk%20develop%0Aon%3A%0A%20%20workflow_dispatch%3A%0A%20%20%23push%3A%0A%20%20%23%20%20branches%3A%0A%20%20%23%20%20%20%20-%20%27develop%27%0A%20%20%23%20%20%20%20-%20%27main%27%0A%20%20pull_request%3A%0A%20%20%20%20types%3A%20%5Bopened%2C%20reopened%5D%0A%20%20%20%20branches%3A%0A%20%20%20%20%20%20-%20%27develop%27%0A%20%20%20%20%20%20-%20%27main%27%0A%0Ajobs%3A%0A%20%20build%3A%0A%20%20%20%20runs-on%3A%20ubuntu-latest%0A%20%20%20%20steps%3A%0A%20%20%20%20%0A%20%20%20%20%20%20-%20name%3A%20Clean%20workspace%0A%20%20%20%20%20%20%20%20run%3A%20%7C%0A%20%20%20%20%20%20%20%20%20%20echo%20%22Cleaning%20up%20previous%20run%22%0A%20%20%20%20%20%20%20%20%20%20rm%20-rf%20%22%24%7B%7B%20github.workspace%20%7D%7D%22%0A%20%20%20%20%20%20%20%20%20%20mkdir%20-p%20%22%24%7B%7B%20github.workspace%20%7D%7D%22%0A%20%20%20%20%20%20-%20name%3A%20Checkout%20pico_gps_teseo_i2c%0A%20%20%20%20%20%20%20%20uses%3A%20actions%2Fcheckout%40v4%0A%20%20%20%20%20%20%20%20with%3A%0A%20%20%20%20%20%20%20%20%20%20path%3A%20pico_gps_teseo_i2c%0A%0A%20%20%20%20%20%20-%20name%3A%20Checkout%20pico-sdk%2Fdevelop%0A%20%20%20%20%20%20%20%20uses%3A%20actions%2Fcheckout%40v4%0A%20%20%20%20%20%20%20%20with%3A%0A%20%20%20%20%20%20%20%20%20%20repository%3A%20raspberrypi%2Fpico-sdk%0A%20%20%20%20%20%20%20%20%20%20ref%3A%20develop%0A%20%20%20%20%20%20%20%20%20%20path%3A%20pico-sdk%0A%0A%20%20%20%20%20%20-%20name%3A%20Checkout%20pico-sdk%20submodules%0A%20%20%20%20%20%20%0A%20%20%20%20%20%20%20%20working-directory%3A%20%24%7B%7Bgithub.workspace%7D%7D%2Fpico-sdk%0A%20%20%20%20%20%20%20%20run%3A%20git%20submodule%20update%20--init%0A%20%20%20%20%20%20-%20name%3A%20Install%20dependencies%0A%20%20%20%20%20%20%20%20run%3A%20%7C%0A%20%20%20%20%20%20%20%20%20%20sudo%20apt-get%20install%20cmake%0A%20%20%20%20%20%20%20%20%20%20%23curl%20-Lo%20gcc-arm-none-eabi.tar.bz2%20%22https%3A%2F%2Fdeveloper.arm.com%2F-%2Fmedia%2FFiles%2Fdownloads%2Fgnu-rm%2F10.3-2021.10%2Fgcc-arm-none-eabi-10.3-2021.10-x86_64-linux.tar.bz2%3Frev%3D78196d3461ba4c9089a67b5f33edf82a%26hash%3D5631ACEF1F8F237389F14B41566964EC%22%0A%20%20%20%20%20%20%20%20%20%20%23sudo%20mkdir%20%2Fopt%2Fgcc-arm-none-eabi%0A%20%20%20%20%20%20%20%20%20%20%23sudo%20tar%20xf%20gcc-arm-none-eabi.tar.bz2%20--strip-components%3D1%20-C%20%2Fopt%2Fgcc-arm-none-eabi%0A%20%20%20%20%20%20%20%20%20%20%23echo%20%27export%20PATH%3D%24PATH%3A%2Fopt%2Fgcc-arm-none-eabi%2Fbin%27%20%7C%20sudo%20tee%20-a%20%2Fetc%2Fprofile.d%2Fgcc-arm-none-eabi.sh%0A%20%20%20%20%20%20%20%20%20%20%23export%20PATH%3D%24PATH%3A%2Fopt%2Fgcc-arm-none-eabi%2Fbin%0A%20%20%20%20%20%20%20%20%20%20%23export%20PICO_TOOLCHAIN_PATH%3D%2Fopt%2Fgcc-arm-none-eabi%2Fbin%0A%20%20%20%20%20%20%20%20%20%20%23source%20%2Fetc%2Fprofile%0A%20%20%20%20%20%20%20%20%20%20%23arm-none-eabi-gcc%20--version%0A%20%20%20%20%20%20%20%20%20%20sudo%20apt%20install%20gcc-arm-none-eabi%0A%20%20%20%20%20%20%20%20%20%20%0A%20%20%20%20%20%20-%20name%3A%20Build%20Project]

Excuses for the formatting. The code editor does not want to accept this code. Click on this link for a better view.

When you create this script in the .github/workflows folder, it 'll kick off each time a pull rrequest is opened for main or develop. But it will not impact the pull request.
If you want to make pull requests dependent on successful build, you 'll also hav to create a ruleset for the branch.

On your repository's web page on GitHub, select settings -> Rules -> Rulesets.
If the branch(es) you want to protect don't have a ruleset yet, create one. Else you can update the existing one.

The first checkbox will take care that the branches you want to protect, can only accept commits via a pull request. When you work together as a team, it's good that branch owners can check code before it's merged in the code base.
The second check also adds the condition, that the build job must complete in good order.

A developer that submits a pull request, gets this page:

They don't have to wait for this to complete. They 'd get an email if it failed. Once the job is completed, the reviewer sees the screen capture I posted at the start of this blog. If the job was successful, code review and merge can happen.

How does it fit in my workflow:

I created another action earlier: [mention:4b25dc423d2f4b2fb72ecb0d54b0dfb1:46448885d0e64133bbfbf0cd7b0fd6f7] . Together, the 2 automate a decent part of code management:

the build validation described here, when a pull request is made to development or main
when a pull request to main is accepted and merged by the branch manager (me :) ), the doucmentation is regenerated and published to github.io.

Future improvements:

I'm considering to let the job create a project release, when a new Version TAG is created in the repository. I'd have to make these changes:

add trigger on TAG creation event. Filter on tags that start with 'v'.
change the build type from Debug to Release
use a GitHub Action to create a release in the repository, and upload the .uf2 file as asset to that release.

Link to all posts.

RE: C++ callbacks and templates

Jan Cumps — Thu, 27 Jun 2024 15:57:46 GMT

comment out this requires line in the template definition.

requires std::is_void<R>::value || std::is_arithmetic_v<R>

It's code that doesn't execute anything but helps the developer to use supported attributes.
The current GNU toolchain for Renesas is 1 version too low for this.

If you don't have this line, and use a non-supported return type for the callback, you 'll get a compile error anyway.
But it 'll be a more cryptic one, at the first line where the code tries to do an operation that your type doesn't support.
In my template, that will be at the return 0; line. That's the only line that doesn't work for any type of return value.

RE: C++ callbacks and templates

flyingbean — Thu, 27 Jun 2024 15:21:24 GMT

I just got a new board from Renesas. Will try e2 studio after my vacation this Summer.

RE: C++ callbacks and templates

Jan Cumps — Fri, 21 Jun 2024 19:22:45 GMT

Most of this design only has compile time cost. The only thing that has some runtime cost is the std::function invocation. This part of code:

(*_callback)(args...);

There are four function calls in between this call and the actual execution of the callback function registered. Not a lot of code is executed, but four calls nonetheless.
I'd consider C++ abstractions cheap. But if 4 calls are too much for the design you are working on, this is not your solution.

We're not talking a lot of clock ticks though - this is all lean.

The cheapest way will most likely be to write callback functionality in assembler or using C style (both without type safety and object awareness). On a controller like the Pico, I think that the cost is ignorable in the majority of firmware designs.

C++ and templates: callbacks that return a value, or a void

Jan Cumps — Fri, 21 Jun 2024 16:38:59 GMT

In C(++), a function can return a value. Or a void.
A function with a return value ends with return X;.
A function that returns void, has a last line return;. Without value. (and you don't have to write that return;, but that doesn't matter in this discussion)
When using templates, this needs consideration, if you allow the return type to be "templated" and you want to support void as one of the options for a return value of a member.

A void function (named a procedure in a lot of programming languages) is different than a function that returns something. Internally and conceptually.
internally: the return value is a position on the stack. void functions don't have that position.
conceptually: ignoring the internally difference, and returning something in a void() function anyways, breaks the C(++) language. Also not returning a value (of the correct type) in a function that does require a return value, fails to compile.

I wrote a templated class that can call a callback. And I wanted it to support returning numbers / bools.
The thing is: when no callback function is set, the class had to work too. It has to return a value in that case .So I wrote this code:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:4d286c93-24ed-4546-a90f-6b5a6f687f5b:type=c_cpp&text=%09inline%20R%20call%28Args...%20args%29%20%7B%0D%0A%09%09if%20%28_callback%20%3D%3D%20nullptr%29%20%7B%0D%0A%09%09%09return%200%3B%20%2F%2F%20R%20can%20only%20be%20a%20arithmetic%20type.%200%20should%20work%20as%20default.%0D%0A%09%09%7D%0D%0A%09%09return%20%28%2A_callback%29%28args...%29%3B%0D%0A%09%7D]

This works great for boolean, integer, float return values. But it you want to support callbacks that don't have a return value, it will fail.
If R is type void, the compilation will not allow return 0;. And if R is a number, compilation will not allow return;.

solution: constant expressions

In C++ , we can write constant expressions. A condition that's checked at compile time. If it's true, the containing block will be compiled. If it's false, not.
A bit related to the C style #ifdef , but context aware. A constant expression knows the code it's acting upon (including parameter types). These constant expressions understand C++ source code.
What they have in common with defines: they both are static: they resolve everything during compilation. They have no runtime cost.

I use this construct to have different behaviour if the return type of my callback function is void, and when it's an arithmetic (number) type:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:5aca7d31-2da0-4e90-91a2-5ffe4f71e25c:type=c_cpp&text=%09%2F%2A%0D%0A%09%20%2A%20R%20can%20either%20be%20an%20arithmetic%20type%2C%20or%20void%0D%0A%09%20%2A%2F%0D%0A%09inline%20R%20call%28Args...%20args%29%20%7B%0D%0A%09%09if%20constexpr%20%28std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%0D%0A%09%09%09if%20%28_callback%20%3D%3D%20nullptr%29%20%7B%0D%0A%09%09%09%09return%3B%0D%0A%09%09%09%7D%0D%0A%09%09%09%28%2A_callback%29%28args...%29%3B%0D%0A%09%09%7D%0D%0A%0D%0A%09%09if%20constexpr%20%28%21%20std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%0D%0A%09%09%09if%20%28_callback%20%3D%3D%20nullptr%29%20%7B%0D%0A%09%09%09%09return%200%3B%20%2F%2F%20R%20can%20only%20be%20a%20arithmetic%20type.%200%20should%20work%20as%20default.%0D%0A%09%09%09%7D%0D%0A%09%09%09return%20%28%2A_callback%29%28args...%29%3B%0D%0A%09%09%7D%0D%0A%09%7D]

You can see that when my templated code is configured for a callback function that returns a bool or a number, it 'll use the lower part, and always return a value.
When the template is configured for a void() type of callback (a procedure), it just returns, without a return value.

This compiles, runs, is type safe and has no runtime impact. if constexpr gets resolved when you build the code. If your code doesn't have void() callbacks, the top part doesn't get compiled. If it doesn't have callbacks that expect a return value, the bottom part doesn't get compiled.

Check my set of test cases below, to see how this works:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:26697407-1dbe-4730-b1dd-8560c409242e:type=c_cpp&text=%23include%20%3Ccstdio%3E%0A%23include%20%22callbackmanager.h%22%0A%23include%20%3Cstring%3E%0A%0Aclass%20MyClass%20%7B%0Apublic%3A%0A%09inline%20int%20handler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20const%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20static%20inline%20int%20staticHandler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%20%20%7D%0A%7D%3B%0A%0Aint%20functionHandler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20return%20num1%20%2B%20num2%3B%0A%7D%0A%0Aint%20main%28%29%20%7B%0A%0A%20%20%20%20int%20a%20%3D%204%3B%0A%20%20%20%20int%20b%20%3D%205%3B%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20object%20method%0A%20%20%20%20MyClass%20myClass%3B%0A%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20capture%20myClass%20and%20call%20the%20object%20method%0A%20%20%20%20cb.set%28%5B%26myClass%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20myClass.handler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb.call%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20static%20method%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20call%20the%20static%20method%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20MyClass%3A%3AstaticHandler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb.call%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20C%20function%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20call%20the%20classic%20C%20function%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20functionHandler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb.call%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20pure%20lambda%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%20%3D%20cb.call%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20return%20a%20bool%0A%20%20%20%20Callback%3Cbool%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20bool%20%7B%0A%20%20%20%20%20%20%20%20return%20num1%20%3D%3D%20num2%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20printf%28%22Value%3A%20%25s%5Cn%22%2C%20cb.call%28a%2C%20b%29%20%3F%20%22true%22%20%3A%20%22false%22%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20use%20a%20callback%20that%20returns%20void%0A%20%20%20%20Callback%3Cvoid%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20%20%20%20%20printf%28%22void%20gets%20num1%3A%20%25i%2C%20num2%3A%20%25i%5Cn%22%2C%20num1%2C%20num2%29%3B%0A%20%20%20%20%09fflush%28stdout%29%3B%0A%20%20%20%20%20%20%20%20return%3B%0A%20%20%20%20%7D%29%3B%0A%20%20%20%20cb.call%28a%2C%20b%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20use%20a%20callback%20that%20returns%20void%2C%20and%20has%20no%20attributes%0A%20%20%20%20Callback%3Cvoid%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28%29%20%7B%0A%20%20%20%20%20%20%20%20printf%28%22void%20with%20no%20parameters%5Cn%22%29%3B%0A%20%20%20%20%09fflush%28stdout%29%3B%0A%20%20%20%20%20%20%20%20return%3B%0A%20%20%20%20%7D%29%3B%0A%20%20%20%20cb.call%28%29%3B%0A%09%7D%0A%0A%09%2F%2A%0A%09%7B%20%2F%2F%20scenario%3A%20use%20an%20unsupported%20%28non-fundamental%29%20type%20for%20return%20value%20R%0A%09%20%20%2F%2F%20this%20will%20generate%20a%20compile%20error%0A%20%20%20%20Callback%3Cstd%3A%3Astring%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%09%7D%0A%2A%2F%0A%0A%7D]

a constexpr knows "everything" about your code. When you use it in a template class, it will know for what types your project will use that template class. Then it 'll take care that it 'll only send that part of the code to the compiler, that is needed for your project.

For classes like the one that I'm writing, this is great. My class has no clue how it 'll be used. But I provide logic for a set of scenarios that I want to support.
C++ constructs like constexpr will take care that this flexibility has no cost when executing the code. All code gets checked at compilation, and needs to pass the strict C++ type checks. But at no cost for the final firmware.

C++ and templates: restrict what types can be used in a template

Jan Cumps — Mon, 17 Jun 2024 15:33:54 GMT

When you use templates in C++, the user can normally plug any C type in a program. For a template class I developed (read [mention:95e9f4be67c8415a81cfd67f3fd1ce81:46448885d0e64133bbfbf0cd7b0fd6f7] ), I want to restrict one of the template arguments: R. This is the type of the return value of a callback function. The restriction that I want to impose, is that the function should not return an object, array, string, ... . Numeric and bool types should do. Or return nothing (void).

I want to be able to return a 0 if no function is set in _callback. So as long as the return value is a C++ arithmetic types, I'll be good. My mechanism will fail if a developer wants to use functions that return strings, arrays, objects, ...
I think that being able to return any arithmetic type is flexible enough for a generic callback handler.

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:7669d1fa-464c-4db9-8e4d-a9e6424bdb32:type=c_cpp&text=template%20%3Ctypename%20R%2C%20typename...%20Args%3E%0A%2F%2F%20restrict%20to%20arithmetic%20data%20types%20for%20return%20value%2C%20or%20void%0A%20%20requires%20std%3A%3Ais_void%3CR%3E%3A%3Avalue%20%7C%7C%20std%3A%3Ais_arithmetic_v%3CR%3E%0Aclass%20Callback%20%7B%0A%0A%2F%2F%20...%0A%0A%09%2F%2A%0A%09%20%2A%20R%20can%20either%20be%20an%20arithmetic%20type%2C%20or%20void%0A%09%20%2A%2F%0A%09inline%20R%20call%28Args...%20args%29%20%7B%0A%09%09if%20constexpr%20%28std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%0A%09%09%09if%20%28_callback%20%3D%3D%20nullptr%29%20%7B%0A%09%09%09%09return%3B%0A%09%09%09%7D%0A%09%09%09%28%2A_callback%29%28args...%29%3B%0A%09%09%7D%0A%0A%09%09if%20constexpr%20%28%21%20std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%0A%09%09%09if%20%28_callback%20%3D%3D%20nullptr%29%20%7B%0A%09%09%09%09return%200%3B%20%2F%2F%20R%20can%20only%20be%20a%20arithmetic%20type.%200%20should%20work%20as%20default.%0A%09%09%09%7D%0A%09%09%09return%20%28%2A_callback%29%28args...%29%3B%0A%09%09%7D%0A%09%7D%0A%0A%2F%2F%20...]

I could do nothing. In that case the developer would get a compilation error on this line in my code: return 0;. And they 'll have to go and investigate why my code throws an error.

C++ now has a mechanism that's called concept. With that, I can restrict the C++ type that a particular template attribute can have. I will use that to only allow arithmetic types for the return value type R.
When doing that, the compiler will give a clear message, pointing to the user's code line where they defined an invalid return type:

78 | Callback<std::string, const int&, const int&> cb; error: template constraint failure for 'template<class R, class ... Args> requires std::is_arithmetic<_Tp>::value class Callback'
note: constraints not satisfied

Thank you for reading. Check [mention:4e1bda4473fd4193bb9be6c83c5309f4:46448885d0e64133bbfbf0cd7b0fd6f7] for yet another dive into hip C++...

RE: C++ and templates: restrict what types can be used in a template

Jan Cumps — Fri, 21 Jun 2024 08:19:08 GMT

I added the option to use a callback that doesn't return anything , e.g.: void handler(...)

First, I allowed the template constraint to accept both arithmetic and void return values.

template <typename R, typename... Args>
// restrict to arithmetic data types for return value, or void
  requires std::is_void<R>::value || std::is_arithmetic_v<R>
class Callback {

And altered the call() function in the template, to not return a value if the return type is void:

	/*
	 * R can either be an arithmetic type, or void
	 */
	inline R call(Args... args) {
		if constexpr (std::is_void<R>::value) {
			if (_callback == nullptr) {
				return;
			}
			(*_callback)(args...);
		}

		if constexpr (! std::is_void<R>::value) {
			if (_callback == nullptr) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			}
			return (*_callback)(args...);
		}
	}

Here's an example that uses a bool handler,

	// scenario: return a bool
    Callback<bool, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> bool {
        return num1 == num2;
    });

    printf("Value: %s\n", cb.call(a, b) ? "true" : "false");
	fflush(stdout);
	}

and a void handler:

    // scenario: use void
    Callback<void, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) {
        return;
    });
    cb.call(a, b);

There are more lines of code in the template class definition. But all of that is compile time resolved.

No executable code is added.

RE: C++ callbacks and templates

Jan Cumps — Wed, 19 Jun 2024 19:38:06 GMT

I've been testing it with toolchains.

Works with:

NXP MCUXpresso
Pico C/C++ SDK 1.5
Renesas e2 studio with gcc toolchain (everything, except the optional clause requires std::is_arithmetic<R>::value)
Eclipse with the arm linux cross-compiler (for Raspberry Pi, BB, ...)

Does not work with:

Arduino IDE 2.0 avr-gcc: compiler version 7.3 is too low
Arduino IDE 2.0 arm-gcc: compiler version 7.2 is too low

RE: C++ and templates: restrict what types can be used in a template

Jan Cumps — Wed, 19 Jun 2024 18:14:25 GMT

shabaz I found where you can set it for Arduino IDE 2.X on windows:

C:\Users\jancu\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.4\platform.txt

You need to replace jancu with your windows user name, and controller family with the board you are working for. And std=gnu++11 with std=c++20

compiler.cpp.flags=-c -g -Os {compiler.warning_flags} -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto

edit: I don't think that this is useful for code that you want to share with others.
edit edit: the setting gets overwritten when updating the IDE
edit edit edit: and avr-gcc 7.x does not support c++20

RE: C++ callbacks and templates

flyingbean — Wed, 19 Jun 2024 14:45:12 GMT

Great tip. I could use the template in my projects here.

RE: C++ and templates: restrict what types can be used in a template

Jan Cumps — Tue, 18 Jun 2024 19:09:58 GMT

no, the option is not there

RE: C++ and templates: restrict what types can be used in a template

shabaz — Tue, 18 Jun 2024 19:03:49 GMT

Ahh thanks for the tip! Simpler to remember than the compile-line option I was using for Pico SDK.

RE: C++ and templates: restrict what types can be used in a template

Jan Cumps — Tue, 18 Jun 2024 18:58:05 GMT

when you press ctl+shift+p in Arduino IDE2, you get a command pallet. There you can set preferences user/workspace (with a form or directly in settings.json)
If the dialect can be set, I'd suspect it's there ...

RE: C++ and templates: restrict what types can be used in a template

Jan Cumps — Tue, 18 Jun 2024 15:51:28 GMT

for pico C sdk:

for eclipse:

No idea how to set in Arduino IDE V2. V1 had a platform file, that you could edit.

RE: C++ and templates: restrict what types can be used in a template

shabaz — Tue, 18 Jun 2024 15:07:23 GMT

Very interesting!

If using g++ to build it, I correctly see the following:

error: 'requires' does not name a type
  requires std::is_arithmetic<R>::value

note: 'requires' only available with '-std=c++20' or '-fconcepts'

All is fine, of course, when I add the specified switch.

However, Arduino IDE is a bit vague:

error: 'requires' does not name a type
 requires std::is_arithmetic<R>::value
 ^~~~~~~~

exit status 1

Compilation error: 'requires' does not name a type

It fails to mention that the reason is the switch is missing. A pity the IDE doesn't support it, because this sort of feature is excellent for real-time applications, and would be a nice way to demonstrate. Still, at least Pico can build with it (using -std=c++20 in the COMPILE_OPTIONS in CMakeLists.txt

RE: C++ callbacks and templates: make the Callback class call an object member, a static member, a C function and a pure lambda function

Jan Cumps — Sun, 16 Jun 2024 17:02:24 GMT

Example program for a Pico:

a Led object knows how to toggle
the toggle method is set as callback
when a rising edge interrupt occurs on GPIO 27 (where a button is attached), the callback is called.
The usual bounce happens if you don't filter the signal, but for a demo it will do.

#include "pico/stdlib.h"
#include "hardware/gpio.h"

#include <cstdio>
#include <string>
#include "callbackmanager.h"

// button on pico eurocard
#define BUTTON (27)

class Led {
public:
      void init() {
        gpio_init(PICO_DEFAULT_LED_PIN);
        gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);
      }
      int toggle() {
        // toggle a led, then exit
        gpio_put(PICO_DEFAULT_LED_PIN, !gpio_get(PICO_DEFAULT_LED_PIN));
        return 0;
      }
};

Callback<int> cb_button;
Led led;

/*
handle SDK HAL gpio callback.
hand over to the Callback object
*/
void gpio_hal_callback(uint gpio, uint32_t events) {
  if((gpio == BUTTON) && ((events & GPIO_IRQ_EDGE_RISE))) {
      // HAL reports we received a rising edge from the button
      // invoke callback
      cb_button.call();
  }
}

int main() {
    stdio_init_all();
    gpio_init(BUTTON);
    gpio_set_dir(BUTTON, GPIO_IN);
    gpio_set_pulls(BUTTON, true, false);

    led.init();

    cb_button.set([]() -> int {
        return led.toggle();
    });

    // enable SDK HAL interrupt for gpio
    gpio_set_irq_enabled_with_callback(BUTTON, GPIO_IRQ_EDGE_RISE, true, &gpio_hal_callback);

    while(true) {}
}

In this example, you see 2 variations on the previous examples:

- the Callback template can also be used with 0 attributes.

Callback<int> cb_button;

In this case, the class will only allow that you set handlers that take no arguments (the int is the return value type).

- I did not put anything in between the lambda []. Because the cb_button object is a global object. You don't have to capture global objects, because lambdas (like any code in your program) can access them. (It actually generates a compile warning if you try to capture a global variable for a lambda: capture of variable 'cb_button' with non-automatic storage duration).
I'm deliberately simplifying the explanation here by calling this a global instead of variable with non-automatic storage. But I guess that if you know what non-automatic storage duration is, you don't need my explanation anyway 🙂.

C++ callbacks and templates: make the Callback class call an object member, a static member, a C function and a pure lambda function

Jan Cumps — Sun, 16 Jun 2024 10:25:57 GMT

I developed a templated C++ callback manager: [mention:95e9f4be67c8415a81cfd67f3fd1ce81:46448885d0e64133bbfbf0cd7b0fd6f7] . I claimed that it can call back

a classic C function,
a lambda,
a static class method or
an object method,

and it supports these return types:

void
bool
number
objects (if the class has a default constructor and "is returnable".

But in that first post, I only showed an example where the method of an object was used as callback handler. In this post, I show all 4 scenarios. This time, I'm not showing the power of templates, but the power of lambda functions.

As a refresher, here is the Callback manager. Unchanged since previous post.

callmanager.cpp

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:be901033-936a-48f0-b321-2194d965624d:type=csharp&text=module%3B%0D%0A%0D%0A%23include%20%3Cconcepts%3E%0D%0A%23include%20%3Cfunctional%3E%0D%0A%0D%0Aexport%20module%20callbackmanager%3B%0D%0A%0D%0Anamespace%20callbackmanager%20%7B%0D%0A%0D%0A%2F%2F%20concept%20guards%20what%20types%20of%20return%20values%20we%20can%20handle%0D%0Atemplate%3Ctypename%20R%3E%0D%0Aconcept%20Callbackable%20%3D%20%0D%0A%09std%3A%3Ais_void%3CR%3E%3A%3Avalue%20%7C%7C%0D%0A%09std%3A%3Ais_arithmetic_v%3CR%3E%20%7C%7C%0D%0A%09std%3A%3Ais_class_v%3CR%3E%3B%0D%0A%0D%0Aexport%20template%20%3CCallbackable%20R%2C%20typename...%20Args%3E%0D%0Aclass%20Callback%20%7B%0D%0A%09using%20callbackfunction_t%20%3D%20std%3A%3Afunction%3CR%28Args...%29%3E%3B%09%0D%0Apublic%3A%0D%0A%09Callback%28%29%20%3A%20callback_%28nullptr%29%2C%20is_callback_set%28false%29%7B%7D%0D%0A%0D%0A%09inline%20void%20set%28callbackfunction_t%20callback%29%20%7B%0D%0A%09%20%20%20%20callback_%20%3D%20callback%3B%0D%0A%09%09is_callback_set%20%3D%20true%3B%0D%0A%09%7D%0D%0A%0D%0A%09inline%20void%20unset%28%29%20%7B%0D%0A%09%09callback_%20%3D%20nullptr%3B%0D%0A%09%09is_callback_set%20%3D%20false%3B%0D%0A%09%7D%0D%0A%0D%0A%09%5B%5Bdeprecated%28%22Use%20operator%20%28%29%20instead.%22%29%5D%5D%0D%0A%09inline%20R%20call%28Args...%20args%29%20%7B%0D%0A%09%09return%20%2Athis%28args...%29%3B%0D%0A%09%7D%0D%0A%0D%0A%09inline%20bool%20is_set%28%29%20%7B%0D%0A%09%09return%20is_callback_set%3B%09%09%0D%0A%09%7D%0D%0A%0D%0A%09%2F%2A%0D%0A%09%20%2A%20R%20can%20be%20an%20arithmetic%20type%2C%20an%20object%2C%20or%20void%0D%0A%09%20%2A%2F%0D%0A%09inline%20R%20operator%28%29%28Args...%20args%29%20%7B%0D%0A%09%09if%20constexpr%20%28std%3A%3Ais_void%3CR%3E%3A%3Avalue%29%20%7B%20%20%2F%2F%20void%0D%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0D%0A%09%09%09%09return%3B%0D%0A%09%09%09%7D%20else%20%7B%0D%0A%09%09%09%09%28callback_%29%28args...%29%3B%0D%0A%09%09%09%7D%0D%0A%09%09%7D%20else%20if%20constexpr%20%28std%3A%3Ais_class%3CR%3E%3A%3Avalue%29%20%7B%20%2F%2F%20object%0D%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0D%0A%09%09%09%09return%20R%28%29%3B%0D%0A%09%09%09%7D%20else%20%7B%0D%0A%09%09%09%09return%20%28callback_%29%28args...%29%3B%0D%0A%09%09%09%7D%0D%0A%09%09%7D%20else%20%7B%20%2F%2F%20not%20void%20nor%20object%0D%0A%09%09%09if%20%28%21is_callback_set%29%20%7B%0D%0A%09%09%09%09return%200%3B%20%2F%2F%20R%20can%20only%20be%20a%20arithmetic%20type.%200%20should%20work%20as%20default.%0D%0A%09%09%09%7D%20else%20%7B%0D%0A%09%09%09%09return%20%28callback_%29%28args...%29%3B%0D%0A%09%09%09%7D%0D%0A%09%09%7D%0D%0A%09%7D%0D%0A%0D%0Aprivate%3A%0D%0A%09callbackfunction_t%20callback_%3B%0D%0A%09bool%20is_callback_set%3B%0D%0A%7D%3B%0D%0A%0D%0A%7D%20%2F%2F%20namespace%20callbackmanager]

And here is the code that exercises the 4 scenarios. Each scenario is surrounded by {}. That means that they run in their own little isolated scope, And they don't spoil each other.

First, some code that will be used in the test. They are 3 different types of functions / methods:

MyClass, now with a static and normal member function. So that we can test a scenario where we call an object member, and a scenario where we call a static class member.
classic C function functionHandler().

All 3 do the same thing. They return the sum of two integers.

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:67e10ab6-e502-474d-9c80-fb99b641b071:type=c_cpp&text=%23include%20%3Ccstdio%3E%0A%23include%20%3Cstring%3E%0A%23include%20%3Ctypeinfo%3E%0A%0Aimport%20callbackmanager%3B%0A%0Aclass%20MyClass%20%7B%0Apublic%3A%0A%20%20%20%20%20%20inline%20int%20handler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20const%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20static%20inline%20int%20staticHandler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%20%20%7D%0A%7D%3B%0A%0Aint%20functionHandler%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20return%20num1%20%2B%20num2%3B%0A%7D]

Then the 4 tests:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:246a6207-76fd-41a4-a42a-67202d3f1478:type=c_cpp&text=int%20main%28%29%20%7B%0A%0A%20%20%20%20int%20a%20%3D%204%3B%0A%20%20%20%20int%20b%20%3D%205%3B%0A%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20capture%20myClass%20and%20call%20the%20object%20method%0A%20%20%20%20cb.set%28%5B%26myClass%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20myClass.handler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%20%2F%2F%20We%20might%20be%20on%20an%20embedded%20system%2C%20use%20printf%28%29%20and%20not%20std%3A%3Acout%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20static%20method%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20call%20the%20static%20method%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20MyClass%3A%3AstaticHandler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%20%2F%2F%20We%20might%20be%20on%20an%20embedded%20system%2C%20use%20printf%28%29%20and%20not%20std%3A%3Acout%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20C%20function%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20call%20the%20classic%20C%20function%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20functionHandler%28num1%2C%20num2%29%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%3D%20cb%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%20%2F%2F%20We%20might%20be%20on%20an%20embedded%20system%2C%20use%20printf%28%29%20and%20not%20std%3A%3Acout%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20call%20pure%20lambda%0A%20%20%20%20Callback%3Cint%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20int%20%7B%0A%20%20%20%20%20%20%20%20return%20num1%20%2B%20num2%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20int%20o%20%20%3D%20cb%28a%2C%20b%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25i%5Cn%22%2C%20o%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20return%20a%20bool%0A%20%20%20%20Callback%3Cbool%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20-%3E%20bool%20%7B%0A%20%20%20%20%20%20%20%20return%20num1%20%3D%3D%20num2%3B%0A%20%20%20%20%7D%29%3B%0A%0A%20%20%20%20printf%28%22Value%3A%20%25s%5Cn%22%2C%20cb%28a%2C%20b%29%20%3F%20%22true%22%20%3A%20%22false%22%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%7B%20%2F%2F%20scenario%3A%20use%20void%0A%20%20%20%20Callback%3Cvoid%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0A%20%20%20%20%20%20%20%20return%3B%0A%20%20%20%20%7D%29%3B%0A%20%20%20%20cb%28a%2C%20b%29%3B%0A%09%7D%0A%09%0A%20%20%20%20%7B%20%2F%2F%20scenario%3A%20return%20an%20object%0A%20%20%20%20class%20return_class%20%7B%0A%20%20%20%20public%3A%0A%20%20%20%20%20%20%20%20return_class%28%29%20%3A%20value_%280%29%20%7B%7D%3B%0A%20%20%20%20%20%20%20%20int%20value_%3B%0A%20%20%20%20%7D%3B%0A%0A%09callbackmanager%3A%3ACallback%3Creturn_class%3E%20cb%3B%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0A%20%20%20%20cb.set%28%5B%5D%28%29%20-%3E%20return_class%20%7B%0A%20%20%20%20%20%20%20%20return_class%20rc%3B%0A%20%20%20%20%20%20%20%20rc.value_%20%3D%201%3B%0A%20%20%20%20%20%20%20%20return%20rc%3B%0A%20%20%20%20%7D%29%3B%0A%20%20%20%20return_class%20ret%20%3D%20cb%28%29%3B%0A%20%20%20%20printf%28%22Value%3A%20%25d%5Cn%22%2C%20ret.value_%20%29%3B%0A%09fflush%28stdout%29%3B%0A%09%7D%0A%0A%09%2F%2A%0A%09%7B%20%2F%2F%20scenario%3A%20use%20an%20unsupported%20%28non-fundamental%29%20type%20for%20return%20value%20R%0A%09%20%20%2F%2F%20this%20will%20generate%20a%20compile%20error%0A%20%20%20%20Callback%3Cstd%3A%3Astring%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0A%09%7D%0A%7D]

edit: The template also allows void return values. Some more tests:

[embed:dc8ab71f-3b98-42d9-b0f6-e21e02a0f8e2:313ac996-b26f-41fa-bcc9-ff3275812ccb:type=c_cpp&text=%09%7B%20%2F%2F%20scenario%3A%20use%20void%0D%0A%20%20%20%20Callback%3Cvoid%2C%20const%20int%26%2C%20const%20int%26%3E%20cb%3B%0D%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0D%0A%20%20%20%20cb.set%28%5B%5D%28const%20int%26%20num1%2C%20const%20int%26%20num2%29%20%7B%0D%0A%20%20%20%20%20%20%20%20printf%28%22void%20gets%20num1%3A%20%25i%2C%20num2%3A%20%25i%5Cn%22%2C%20num1%2C%20num2%29%3B%0D%0A%20%20%20%20%09fflush%28stdout%29%3B%0D%0A%20%20%20%20%20%20%20%20return%3B%0D%0A%20%20%20%20%7D%29%3B%0D%0A%20%20%20%20cb.call%28a%2C%20b%29%3B%0D%0A%09%7D%0D%0A%0D%0A%09%7B%20%2F%2F%20scenario%3A%20use%20void%2C%20and%20no%20attributes%0D%0A%20%20%20%20Callback%3Cvoid%3E%20cb%3B%0D%0A%20%20%20%20%2F%2F%20Use%20a%20lambda%20to%20execute%20anonymous%20C%20code%0D%0A%20%20%20%20cb.set%28%5B%5D%28%29%20%7B%0D%0A%20%20%20%20%20%20%20%20printf%28%22void%20with%20no%20parameters%5Cn%22%29%3B%0D%0A%20%20%20%20%09fflush%28stdout%29%3B%0D%0A%20%20%20%20%20%20%20%20return%3B%0D%0A%20%20%20%20%7D%29%3B%0D%0A%20%20%20%20cb.call%28%29%3B%0D%0A%09%7D]

Scenarios, in order of execution: (edit: this was written before I revised the code to support configurable return value. The test code above is adapted, but I didn't change the images below)

call object method
In this one, I create object myClass of type MyClass. Then pass its handle() method as callback.
This was the scenario of the first post.
call static class method
In this test, I don't declare an object of type MyClass. I pass the static MyClass::staticHandle()
classic C function
Here, the callback gets a very common C function, named functionHandler(), as handler.
a pure lambda.
In this test, I pass an anonymous block of code as handler:
return num1 + num2;
return an object. This is added on 09-mar-2025.Works as long as the object supports a default constructor and does not forbid copy / assign.

In each test, the Callback object cb will call the code that's given to it in the set() call. All using the exact same little Callback template class. If you would set breakpoints, here is where the code would stop for each of the 4 cases:

edit: this was written before I replaced call() by operator ()..In your code, don't use cb.call(args), but cb(args). The test code in the blog is adapted, but I didn't change the images.

The test code is available as a Gist.