cpp callback example added

Author: nixiz

async-call-helper/async-call-helper.hpp

@@ -73,14 +73,14 @@ class async_call_helper
 template <typename ...Args>
 struct callback_context {
 void *context;
-void (*callback)(Args...);
+void (*callback)(void*, Args...);
 void operator()(Args... args) noexcept {
-std::invoke(callback, std::forward<Args>(args)...);
+std::invoke(callback, context, std::forward<Args>(args)...);
 }
 };
 
 template <typename ...Args, typename Fn>
-callback_context<void*, Args...> 
+callback_context<Args...> 
 get_context(Fn&& cb) noexcept 
 {
 struct trampoline_t final
@@ -120,7 +120,7 @@ class async_call_helper
 std::function<void(Args...)> callback;
 };
 std::function<void(Args...)> callback = cb;
-return callback_context<void*, Args...> {
+return callback_context<Args...> {
 new trampoline_t(weak_ref(), guard, std::move(callback)),
 &trampoline_t::callback_handle
 };

async-call-helper/external_c_lib.h

@@ -1,16 +1,34 @@
 #pragma once
 
-#include <thread>
 #include <chrono>
+#include <functional>
+#include <thread>
 
 namespace c {
- typedef void(*long_async_function_cb)(void*, int);
+typedef void (*long_async_function_cb)(void*, int);
+
+static void long_async_function(void* context,
+ long_async_function_cb cb,
+ int in_param,
+ int sleep_msec = 1000) {
+ std::thread([=] {
+ std::this_thread::sleep_for(std::chrono::milliseconds(sleep_msec));
+ auto out_param = in_param * 2;
+ cb(context, out_param);
+ }).detach();
+}
+
+} // namespace c
+
+namespace cpp {
+using long_async_function_cb_t = std::function<void(int)>;
+
+static void long_async_function(long_async_function_cb_t cb, int in_param, int sleep_msec = 1000) {
+ std::thread([=] {
+ std::this_thread::sleep_for(std::chrono::milliseconds(sleep_msec));
+ auto out_param = in_param * 2;
+ cb(out_param);
+ }).detach();
+}
 
- static void long_async_function(void* context, long_async_function_cb cb, int in_param, int sleep_msec = 1000) {
- std::thread([=] {
- std::this_thread::sleep_for(std::chrono::milliseconds(sleep_msec));
- auto out_param = in_param * 2;
- cb(context, out_param);
- }).detach();
- }
-}
+} // namespace cpp

async-call-helper/main.cpp

@@ -21,7 +21,7 @@ int main()
  {
  safe_service s(5);
  s.execute();
- std::this_thread::sleep_for(1s);
+ std::this_thread::sleep_for(3s);
  } while(getchar() != 'q');
 
 return 0;

async-call-helper/safe-service.cpp

@@ -1,11 +1,8 @@
-#include <iostream>
 #include "safe-service.h"
+#include <iostream>
 #include "external_c_lib.h"
 
-
-safe_service::safe_service(int in_param)
- : param(new int(in_param))
-{
+safe_service::safe_service(int in_param) : param(new int(in_param)) {
  std::cout << "ctor service \n";
 }
 
@@ -16,30 +13,28 @@ safe_service::~safe_service() {
 
 static inline void safe_response_cb(void* context, int out_param) {
  auto srv_ptr = asyn_call_token::from_context<safe_service>(context);
- if (srv_ptr)
- {
+ if (srv_ptr) {
  srv_ptr->response(out_param);
- }
- else
- {
+ } else {
  std::cerr << "no service instance to make callback call\n";
  }
 }
 
 void safe_service::execute() {
- c::long_async_function(get_context(), safe_response_cb, *param);
- 
- auto context = get_context<int>([this] (int o) {
- std::cout << "received response from lambda " << *param << ": " << o << "\n";
- });
- c::long_async_function(context.context, context.callback, *param);
+ // c::long_async_function(get_context(), safe_response_cb, *param);
+
+ // auto context = get_context<int>([this](int o) {
+ //  std::cout << "received response from lambda " << *param << ": " << o << "\n";
+ // });
+ // c::long_async_function(context.context, context.callback, *param);
 
  using namespace std::placeholders;
  auto context_bind = get_context<int>(std::bind(&safe_service::response, this, _1));
  c::long_async_function(context_bind.context, context_bind.callback, *param * 3);
+
+ cpp::long_async_function(context_bind, *param);
 }
 
-void safe_service::response(int out_param)
-{
+void safe_service::response(int out_param) {
  std::cout << "received response for " << *param << ": " << out_param << "\n";
 }