--- /dev/null
+#include <node.h>
+#include <handle_wrap.h>
+
+namespace node {
+
+using v8::Object;
+using v8::Handle;
+using v8::Local;
+using v8::Persistent;
+using v8::Value;
+using v8::HandleScope;
+using v8::FunctionTemplate;
+using v8::String;
+using v8::Function;
+using v8::TryCatch;
+using v8::Context;
+using v8::Arguments;
+using v8::Integer;
+
+
+#define UNWRAP \
+ assert(!args.Holder().IsEmpty()); \
+ assert(args.Holder()->InternalFieldCount() > 0); \
+ HandleWrap* wrap = \
+ static_cast<HandleWrap*>(args.Holder()->GetPointerFromInternalField(0)); \
+ if (!wrap) { \
+ SetErrno(UV_EBADF); \
+ return scope.Close(Integer::New(-1)); \
+ }
+
+
+void HandleWrap::Initialize(Handle<Object> target) {
+ /* Doesn't do anything at the moment. */
+}
+
+
+Handle<Value> HandleWrap::Close(const Arguments& args) {
+ HandleScope scope;
+
+ UNWRAP
+
+ assert(!wrap->object_.IsEmpty());
+ int r = uv_close(wrap->handle__, OnClose);
+
+ wrap->StateChange();
+
+ if (r) {
+ SetErrno(uv_last_error().code);
+
+ wrap->object_->SetPointerInInternalField(0, NULL);
+ wrap->object_.Dispose();
+ wrap->object_.Clear();
+ }
+ return scope.Close(Integer::New(r));
+}
+
+
+HandleWrap::HandleWrap(Handle<Object> object, uv_handle_t* h) {
+ handle__ = h;
+ h->data = this;
+
+ HandleScope scope;
+ assert(object_.IsEmpty());
+ assert(object->InternalFieldCount() > 0);
+ object_ = v8::Persistent<v8::Object>::New(object);
+ object_->SetPointerInInternalField(0, this);
+}
+
+
+HandleWrap::~HandleWrap() {
+ assert(object_.IsEmpty());
+}
+
+
+void HandleWrap::OnClose(uv_handle_t* handle) {
+ HandleWrap* wrap = static_cast<HandleWrap*>(handle->data);
+
+ // The wrap object should still be there.
+ assert(wrap->object_.IsEmpty() == false);
+
+ wrap->object_->SetPointerInInternalField(0, NULL);
+ wrap->object_.Dispose();
+ wrap->object_.Clear();
+
+ delete wrap;
+}
+
+
+} // namespace node
--- /dev/null
+#ifndef HANDLE_WRAP_H_
+#define HANDLE_WRAP_H_
+
+namespace node {
+
+class HandleWrap {
+ public:
+ static void Initialize(v8::Handle<v8::Object> target);
+ static v8::Handle<v8::Value> Close(const v8::Arguments& args);
+
+ protected:
+ HandleWrap(v8::Handle<v8::Object> object, uv_handle_t* handle);
+ virtual ~HandleWrap();
+
+ virtual void StateChange() {}
+
+ v8::Persistent<v8::Object> object_;
+
+ private:
+ static void OnClose(uv_handle_t* handle);
+ // Using double underscore due to handle_ member in tcp_wrap. Probably
+ // tcp_wrap should rename it's member to 'handle'.
+ uv_handle_t* handle__;
+};
+
+
+} // namespace node
+
+
+#endif // HANDLE_WRAP_H_
#include <node.h>
#include <node_buffer.h>
+#include <handle_wrap.h>
#include <stream_wrap.h>
#include <req_wrap.h>
static size_t slab_used;
static uv_stream_t* handle_that_last_alloced;
-Persistent<String> slab_sym;
-Persistent<String> buffer_sym;
-Persistent<String> write_queue_size_sym;
-bool initialized;
+static Persistent<String> slab_sym;
+static Persistent<String> buffer_sym;
+static Persistent<String> write_queue_size_sym;
+static bool initialized;
void StreamWrap::Initialize(Handle<Object> target) {
HandleScope scope;
+ HandleWrap::Initialize(target);
+
slab_sym = Persistent<String>::New(String::NewSymbol("slab"));
buffer_sym = Persistent<String>::New(String::NewSymbol("buffer"));
write_queue_size_sym =
}
-StreamWrap::StreamWrap(Handle<Object> object, uv_stream_t* stream) {
- HandleScope scope;
-
+StreamWrap::StreamWrap(Handle<Object> object, uv_stream_t* stream)
+ : HandleWrap(object, (uv_handle_t*)stream) {
stream_ = stream;
stream->data = this;
- assert(object_.IsEmpty());
- assert(object->InternalFieldCount() > 0);
- object_ = v8::Persistent<v8::Object>::New(object);
- object_->SetPointerInInternalField(0, this);
-
UpdateWriteQueueSize();
}
-StreamWrap::~StreamWrap() {
- assert(object_.IsEmpty());
-}
-
-
-// Free the C++ object on the close callback.
-void StreamWrap::OnClose(uv_handle_t* handle) {
- StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);
-
- // The wrap object should still be there.
- assert(wrap->object_.IsEmpty() == false);
-
- wrap->object_->SetPointerInInternalField(0, NULL);
- wrap->object_.Dispose();
- wrap->object_.Clear();
- delete wrap;
-}
-
-
void StreamWrap::UpdateWriteQueueSize() {
object_->Set(write_queue_size_sym, Integer::New(stream_->write_queue_size));
}
}
}
-// TODO: share me?
-Handle<Value> StreamWrap::Close(const Arguments& args) {
- HandleScope scope;
-
- UNWRAP
-
- assert(!wrap->object_.IsEmpty());
- int r = uv_close((uv_handle_t*) wrap->stream_, OnClose);
-
- if (r) {
- SetErrno(uv_last_error().code);
-
- wrap->object_->SetPointerInInternalField(0, NULL);
- wrap->object_.Dispose();
- wrap->object_.Clear();
- }
- return scope.Close(Integer::New(r));
-}
-
Handle<Value> StreamWrap::Write(const Arguments& args) {
HandleScope scope;
#ifndef STREAM_WRAP_H_
#define STREAM_WRAP_H_
+#include <v8.h>
+#include <node.h>
+#include <handle_wrap.h>
+
namespace node {
-class StreamWrap {
+class StreamWrap : public HandleWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
static v8::Handle<v8::Value> ReadStart(const v8::Arguments& args);
static v8::Handle<v8::Value> ReadStop(const v8::Arguments& args);
static v8::Handle<v8::Value> Shutdown(const v8::Arguments& args);
- static v8::Handle<v8::Value> Close(const v8::Arguments& args);
protected:
StreamWrap(v8::Handle<v8::Object> object, uv_stream_t* stream);
- ~StreamWrap();
-
- v8::Persistent<v8::Object> object_;
+ virtual ~StreamWrap() { }
+ void StateChange() { }
private:
void UpdateWriteQueueSize();
static uv_buf_t OnAlloc(uv_stream_t* handle, size_t suggested_size);
static void OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf);
static void AfterShutdown(uv_shutdown_t* req, int status);
- static void OnClose(uv_handle_t* handle);
size_t slab_offset_;
uv_stream_t* stream_;
#include <node.h>
#include <node_buffer.h>
#include <req_wrap.h>
+#include <handle_wrap.h>
#include <stream_wrap.h>
// Temporary hack: libuv should provide uv_inet_pton and uv_inet_ntop.
typedef class ReqWrap<uv_connect_t> ConnectWrap;
-class TCPWrap : StreamWrap {
+class TCPWrap : public StreamWrap {
public:
static void Initialize(Handle<Object> target) {
+ HandleWrap::Initialize(target);
StreamWrap::Initialize(target);
HandleScope scope;
t->InstanceTemplate()->SetInternalFieldCount(1);
+ NODE_SET_PROTOTYPE_METHOD(t, "close", HandleWrap::Close);
+
NODE_SET_PROTOTYPE_METHOD(t, "readStart", StreamWrap::ReadStart);
NODE_SET_PROTOTYPE_METHOD(t, "readStop", StreamWrap::ReadStop);
NODE_SET_PROTOTYPE_METHOD(t, "write", StreamWrap::Write);
NODE_SET_PROTOTYPE_METHOD(t, "shutdown", StreamWrap::Shutdown);
- NODE_SET_PROTOTYPE_METHOD(t, "close", StreamWrap::Close);
NODE_SET_PROTOTYPE_METHOD(t, "bind", Bind);
NODE_SET_PROTOTYPE_METHOD(t, "listen", Listen);
#include <node.h>
+#include <handle_wrap.h>
// Rules:
//
using v8::Integer;
-class TimerWrap {
+class TimerWrap : public HandleWrap {
public:
static void Initialize(Handle<Object> target) {
HandleScope scope;
+ HandleWrap::Initialize(target);
+
Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("Timer"));
+ NODE_SET_PROTOTYPE_METHOD(constructor, "close", HandleWrap::Close);
+
NODE_SET_PROTOTYPE_METHOD(constructor, "start", Start);
NODE_SET_PROTOTYPE_METHOD(constructor, "stop", Stop);
NODE_SET_PROTOTYPE_METHOD(constructor, "setRepeat", SetRepeat);
NODE_SET_PROTOTYPE_METHOD(constructor, "getRepeat", GetRepeat);
NODE_SET_PROTOTYPE_METHOD(constructor, "again", Again);
- NODE_SET_PROTOTYPE_METHOD(constructor, "close", Close);
target->Set(String::NewSymbol("Timer"), constructor->GetFunction());
}
return scope.Close(args.This());
}
- TimerWrap(Handle<Object> object) {
+ TimerWrap(Handle<Object> object)
+ : HandleWrap(object, (uv_handle_t*) &handle_) {
active_ = false;
int r = uv_timer_init(&handle_);
handle_.data = this;
- assert(r == 0); // How do we proxy this error up to javascript?
- // Suggestion: uv_timer_init() returns void.
- assert(object_.IsEmpty());
- assert(object->InternalFieldCount() > 0);
- object_ = v8::Persistent<v8::Object>::New(object);
- object_->SetPointerInInternalField(0, this);
// uv_timer_init adds a loop reference. (That is, it calls uv_ref.) This
// is not the behavior we want in Node. Timers should not increase the
~TimerWrap() {
if (!active_) uv_ref();
- assert(object_.IsEmpty());
}
void StateChange() {
}
}
- // Free the C++ object on the close callback.
- static void OnClose(uv_handle_t* handle) {
- TimerWrap* wrap = static_cast<TimerWrap*>(handle->data);
- delete wrap;
- }
-
static Handle<Value> Start(const Arguments& args) {
HandleScope scope;
return scope.Close(Integer::New(repeat));
}
- // TODO: share me?
- static Handle<Value> Close(const Arguments& args) {
- HandleScope scope;
-
- UNWRAP
-
- int r = uv_close((uv_handle_t*) &wrap->handle_, OnClose);
-
- if (r) SetErrno(uv_last_error().code);
-
- wrap->StateChange();
-
- assert(!wrap->object_.IsEmpty());
- wrap->object_->SetPointerInInternalField(0, NULL);
- wrap->object_.Dispose();
- wrap->object_.Clear();
-
- return scope.Close(Integer::New(r));
- }
-
static void OnTimeout(uv_timer_t* handle, int status) {
HandleScope scope;
}
uv_timer_t handle_;
- Persistent<Object> object_;
// This member is set false initially. When the timer is turned
// on uv_ref is called. When the timer is turned off uv_unref is
// called. Used to mirror libev semantics.
src/node_dtrace.cc
src/node_string.cc
src/timer_wrap.cc
+ src/handle_wrap.cc
src/stream_wrap.cc
src/tcp_wrap.cc
src/pipe_wrap.cc
projects / platform / upstream / nodejs.git / commitdiff