Add process.IdleWatcher

With priorities. Will be used for process.nextLoop().

src/node.cc

@@ -14,6 +14,7 @@
 #include <node_dns.h>
 #include <node_net.h>
 #include <node_file.h>
+#include <node_idle_watcher.h>
 #include <node_http.h>
 #include <node_signal_handler.h>
 #include <node_stat.h>
@@ -940,6 +941,7 @@ static Local<Object> Load(int argc, char *argv[]) {
 
 
   // Initialize the C++ modules..................filename of module
+  IdleWatcher::Initialize(process);            // idle_watcher.cc
   Stdio::Initialize(process);                  // stdio.cc
   Timer::Initialize(process);                  // timer.cc
   SignalHandler::Initialize(process);          // signal_handler.cc

src/node_constants.cc

@@ -8,11 +8,16 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include <ev.h>
+
 namespace node {
 
 using namespace v8;
 
 void DefineConstants(Handle<Object> target) {
+  NODE_DEFINE_CONSTANT(target, EV_MINPRI);
+  NODE_DEFINE_CONSTANT(target, EV_MAXPRI);
+
   // file access modes
   NODE_DEFINE_CONSTANT(target, O_RDONLY);
   NODE_DEFINE_CONSTANT(target, O_WRONLY);

src/node_idle_watcher.cc

@@ -0,0 +1,118 @@
+// Copyright 2009 Ryan Dahl <ry@tinyclouds.org>
+#include <node_idle_watcher.h>
+
+#include <node.h>
+#include <v8.h>
+
+#include <assert.h>
+
+namespace node {
+
+using namespace v8;
+
+Persistent<FunctionTemplate> IdleWatcher::constructor_template;
+Persistent<String> callback_symbol;
+
+void IdleWatcher::Initialize(Handle<Object> target) {
+  HandleScope scope;
+
+  Local<FunctionTemplate> t = FunctionTemplate::New(IdleWatcher::New);
+  constructor_template = Persistent<FunctionTemplate>::New(t);
+  constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
+  constructor_template->SetClassName(String::NewSymbol("IdleWatcher"));
+
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "start", IdleWatcher::Start);
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "stop", IdleWatcher::Stop);
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "setPriority",
+      IdleWatcher::SetPriority);
+
+  target->Set(String::NewSymbol("IdleWatcher"), constructor_template->GetFunction());
+
+  callback_symbol = NODE_PSYMBOL("callback");
+}
+
+
+Handle<Value> IdleWatcher::SetPriority(const Arguments& args) {
+  IdleWatcher *idle = ObjectWrap::Unwrap<IdleWatcher>(args.Holder());
+
+  HandleScope scope;
+
+  int priority = args[0]->Int32Value();
+  
+  ev_set_priority(&idle->watcher_, priority);
+
+  return Undefined();
+}
+
+
+void IdleWatcher::Callback(EV_P_ ev_idle *w, int revents) {
+  IdleWatcher *idle = static_cast<IdleWatcher*>(w->data);
+
+  assert(w == &idle->watcher_);
+  assert(revents == EV_IDLE);
+
+  HandleScope scope;
+
+  Local<Value> callback_v = idle->handle_->Get(callback_symbol);
+  if (!callback_v->IsFunction()) {
+    idle->Stop();
+    return;
+  }
+
+  Local<Function> callback = Local<Function>::Cast(callback_v);
+
+  TryCatch try_catch;
+
+  callback->Call(idle->handle_, 0, NULL);
+
+  if (try_catch.HasCaught()) {
+    FatalException(try_catch);
+  }
+}
+
+
+// 
+//  var idle = new process.IdleWatcher();
+//  idle.callback = function () { /* ... */  };
+//  idle.start();
+//
+Handle<Value> IdleWatcher::New(const Arguments& args) {
+  HandleScope scope;
+
+  IdleWatcher *s = new IdleWatcher();
+  s->Wrap(args.This());
+
+  return args.This();
+}
+
+
+Handle<Value> IdleWatcher::Start(const Arguments& args) {
+  HandleScope scope;
+
+  IdleWatcher *idle = ObjectWrap::Unwrap<IdleWatcher>(args.Holder());
+
+  ev_idle_start(EV_DEFAULT_UC_ &idle->watcher_);
+
+  idle->Ref();
+
+  return Undefined();
+}
+
+
+Handle<Value> IdleWatcher::Stop(const Arguments& args) {
+  HandleScope scope;
+  IdleWatcher *idle = ObjectWrap::Unwrap<IdleWatcher>(args.Holder());
+  idle->Stop();
+  return Undefined();
+}
+
+
+void IdleWatcher::Stop () {
+  if (watcher_.active) {
+    ev_idle_stop(EV_DEFAULT_UC_ &watcher_);
+    Unref();
+  }
+}
+
+
+}  // namespace node

src/node_idle_watcher.h

@@ -0,0 +1,41 @@
+// Copyright 2009 Ryan Dahl <ry@tinyclouds.org>
+#ifndef NODE_IDLE_H_
+#define NODE_IDLE_H_
+
+#include <node_object_wrap.h>
+#include <ev.h>
+
+namespace node {
+
+class IdleWatcher : ObjectWrap {
+ public:
+  static void Initialize(v8::Handle<v8::Object> target);
+
+ protected:
+  static v8::Persistent<v8::FunctionTemplate> constructor_template;
+
+  IdleWatcher() : ObjectWrap() {
+    ev_idle_init(&watcher_, IdleWatcher::Callback);
+    watcher_.data = this;
+  }
+
+  ~IdleWatcher() {
+    ev_idle_stop(EV_DEFAULT_UC_ &watcher_);
+  }
+
+  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static v8::Handle<v8::Value> Start(const v8::Arguments& args);
+  static v8::Handle<v8::Value> Stop(const v8::Arguments& args);
+  static v8::Handle<v8::Value> SetPriority(const v8::Arguments& args);
+
+ private:
+  static void Callback(EV_P_ ev_idle *watcher, int revents);
+
+  void Stop();
+
+  ev_idle watcher_;
+};
+
+}  // namespace node
+#endif  // NODE_IDLE_H_
+

test/mjsunit/test-idle-watcher.js

@@ -0,0 +1,14 @@
+process.mixin(require("./common"));
+
+var complete = false;
+var idle = new process.IdleWatcher();
+idle.callback = function () {
+  complete = true;
+  idle.stop();
+};
+idle.setPriority(process.EVMAXPRI);
+idle.start();
+
+process.addListener('exit', function () {
+  assert.ok(complete);
+});

wscript

@@ -338,6 +338,7 @@ def build(bld):
     src/node_stat.cc
     src/node_stdio.cc
     src/node_timer.cc
+    src/node_idle_watcher.cc
   """
   node.includes = """
     src/