gistfile1.txt

#include <nan.h>

#ifndef _WIN32
#include <unistd.h>
#define Sleep(x) usleep((x)*1000)
#endif

using namespace v8;

class AsyncEmitter : public node::ObjectWrap
{
public:
  static void Init(Handle<Object> exports);

private:
  explicit AsyncEmitter();
  virtual ~AsyncEmitter();

  static Persistent<Function> constructor;
  static NAN_METHOD(New);
  static NAN_METHOD(Start);

};

Persistent<Function> AsyncEmitter::constructor;
AsyncEmitter::AsyncEmitter()
{
};

AsyncEmitter::~AsyncEmitter()
{
};

void AsyncEmitter::Init(Handle<Object> exports)
{
  NanScope();

  // constructor
  Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(AsyncEmitter::New);
  tpl->SetClassName(NanNew("AsyncEmitter"));
  tpl->InstanceTemplate()->SetInternalFieldCount(1);

  // prototype
  NODE_SET_PROTOTYPE_METHOD(tpl, "start", AsyncEmitter::Start);

  NanAssignPersistent(constructor, tpl->GetFunction());
  exports->Set(NanNew("AsyncEmitter"), tpl->GetFunction());
}

// v8 exposed methods
NAN_METHOD(AsyncEmitter::New)
{
  NanScope();
  AsyncEmitter *object = new AsyncEmitter();
  object->Wrap(args.This());
  NanReturnValue(args.This());
}

class Worker : public NanAsyncWorker
{
public:
  Worker(NanCallback *callback, AsyncEmitter *emitter)
    : NanAsyncWorker(callback),
      m_emitter(emitter)
  {}
  ~Worker() {}

  void Execute() {
    Sleep(1000);

    Local<Value> argv[] = {
      NanNew<String>("test message")
    };

    Local<Object> emitter = NanNew<Object>(m_emitter->persistent());
    NanMakeCallback(emitter, "emit", 1, argv);

    Sleep(1000);
  }

private:
  AsyncEmitter *m_emitter;

};

NAN_METHOD(AsyncEmitter::Start)
{
  NanScope();
  AsyncEmitter *asyncEmitter = ObjectWrap::Unwrap<AsyncEmitter>(args.This());
  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
  NanAsyncQueueWorker(new Worker(callback, asyncEmitter));
  NanReturnUndefined();
}

void InitAll(Handle<Object> exports) {
  AsyncEmitter::Init(exports);
}

NODE_MODULE(addon, InitAll)