Class TokenData

src/NodeRTLib/ProjectFiles/node-async.h:101–155

 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();
      SetHandleCallbackData(asyncHandle->data, callback, receiver);

      return asyncHandle;
    }

    static uv_idle_t* NewIdleToken() {
      uv_idle_t* idleHandle = new uv_idle_t;
      uv_idle_init(uv_default_loop(), idleHandle);

      SetHandleData(idleHandle->data);
      return idleHandle;
    }

    static uv_idle_t* NewIdleToken(Handle<Function> callback,
                                   Handle<Value> receiver) {
      uv_idle_t* idleHandle = NewIdleToken();
      SetHandleCallbackData(idleHandle->data, callback, receiver);

      return idleHandle;
    }

    virtual ~TokenData() { callbackData.Reset(); }

   private:
    static void SetHandleData(void*& handleData) {
      handleData = new TokenData();
    }

    static void SetHandleCallbackData(void* handleData,
                                      Handle<Function> callback,
                                      Handle<Value> receiver) {
      TokenData* Token = static_cast<TokenData*>(handleData);
      Token->callbackData.Reset(CreateCallbackData(callback, receiver));
    }

    TokenData() {}

    Persistent<Object> callbackData;
    std::function<void()> func;

    friend Async;
  };

 public:
  template <typename TInput, typename TResult>