async_helpers.hpp

#ifndef _DITTO_ASYNC_HELPERS_
#define _DITTO_ASYNC_HELPERS_
 
#include "Errors.hpp"
 
#include <future>
 
namespace ditto {
 
// Type-independent base class for the AsyncContext<T> template
class AsyncContextBase {
public:
  virtual ~AsyncContextBase() = default;
};
 
// "free" function for any class derived from AsyncContextBase.
extern "C" void async_context_deleter(void *ptr) {
  auto ctx_ptr = static_cast<AsyncContextBase *>(ptr);
  delete ctx_ptr;
}

template <typename ReturnType> class AsyncContext : public AsyncContextBase {
  std::promise<ReturnType> promise;
 
public:
  typedef ReturnType return_type;

  AsyncContext() = default;
 
  AsyncContext(const AsyncContext &) = delete;
  AsyncContext &operator=(const AsyncContext &) = delete;
 
  AsyncContext(AsyncContext &&) = delete;
  AsyncContext &operator=(AsyncContext &&) = delete;

  void set_value(ReturnType value) { promise.set_value(value); }

  void set_exception(std::exception_ptr e) { promise.set_exception(e); }

  std::future<ReturnType> get_future() { return promise.get_future(); }

  void (*get_deleter())(void *) { return async_context_deleter; }
};

 
#define DITTO_DEFINE_ASYNC_CONTEXT_CALLBACK(cb_name, FfiResultType,            \
                                            SuccessType)                       \
  extern "C" void cb_name(void *env_ptr, FfiResultType ffi_result) {           \
    auto ctx = static_cast<AsyncContext<SuccessType> *>(env_ptr);              \
    if (ffi_result.error != nullptr) {                                         \
      ctx->set_exception(                                                      \
          std::make_exception_ptr(DittoError(ffi_result.error)));              \
      return;                                                                  \
    }                                                                          \
    ctx->set_value(ffi_result.success);                                        \
  }
 
} // namespace ditto
 
#endif