Class Async

src/NodeRTLib/ProjectFiles/node-async.h:56–377

typedef std::function<void(int, Handle<Value>*)> InvokeCallbackDelegate;

class Async {
 public:
  template <typename TInput, typename TResult>
  struct Baton {
    int error_code;
    std::wstring error_message;

    // Custom data
    std::shared_ptr<TInput> data;
    std::shared_ptr<TResult> result;
    std::shared_ptr<Persistent<Value>> callback_args;
    unsigned callback_args_size;

    Baton() { callback_args_size = 0; }

    void setCallbackArgs(Handle<Value>* argv, int argc) {
      HandleScope scope;

      callback_info.reset(new Persistent<Value>[argc],
                          [](Persistent<Value>* ptr) { delete[] ptr; });

      callback_args_size = 0;

      for (int i = 0; i < argc; i++) {
        // callback_info.get()[i] = argv[i];
        callback_info.get()[i].Reset(argv[i]);
      }
    }

    virtual ~Baton() {
      for (int i = 0; i < callback_args_size; i++) {
        callback_info.get()[i].Reset();
      }
    }

   private:
    uv_work_t request;
    std::function<void(Baton*)> doWork;
    std::function<void(Baton*)> afterWork;
    Nan::Persistent<Object> callbackData;

    friend Async;
  };

 private:
  class TokenData {
   public:
    static uv_async_t* NewAsyncToken() {
      uv_async_t* asyncHandle = new uv_async_t;
      uv_async_init(uv_default_loop(), asyncHandle, AsyncCb);
      SetHandleData(asyncHandle->data);

      return asyncHandle;
    }

    static uv_async_t* NewAsyncToken(Handle<Function> callback,
                                     Handle<Value> receiver) {
      uv_async_t* asyncHandle = NewAsyncToken();