public:

ObjectWrap ( ) {

refs_ = 0;

}

virtual ~ObjectWrap ( ) {

if (!handle_.IsEmpty()) {

assert(handle_.IsNearDeath());

handle_.ClearWeak();

handle_->SetInternalField(0, v8::Undefined());

handle_.Dispose();

handle_.Clear();

}

}

template <class T>

static inline T* Unwrap (v8::Handle<v8::Object> handle) {

assert(!handle.IsEmpty());

assert(handle->InternalFieldCount() > 0);

return static_cast<T*>(handle->GetPointerFromInternalField(0));

}

v8::Persistent<v8::Object> handle_; // ro

protected:

inline void Wrap (v8::Handle<v8::Object> handle) {

assert(handle_.IsEmpty());

assert(handle->InternalFieldCount() > 0);

handle_ = v8::Persistent<v8::Object>::New(handle);

handle_->SetPointerInInternalField(0, this);

MakeWeak();

}

inline void MakeWeak (void) {

handle_.MakeWeak(this, WeakCallback);

}

/* Ref() marks the object as being attached to an event loop.

virtual void Ref() {

assert(!handle_.IsEmpty());

refs_++;

handle_.ClearWeak();

}

/* Unref() marks an object as detached from the event loop. This is its

virtual void Unref() {

assert(!handle_.IsEmpty());

assert(!handle_.IsWeak());

assert(refs_ > 0);

if (--refs_ == 0) { MakeWeak(); }

}

int refs_; // ro

private:

static void WeakCallback (v8::Persistent<v8::Value> value, void *data) {

ObjectWrap *obj = static_cast<ObjectWrap*>(data);

assert(value == obj->handle_);

assert(!obj->refs_);

assert(value.IsNearDeath());

delete obj;

}