HandleScope scope(env->isolate());

Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New);

t->InstanceTemplate()->SetInternalFieldCount(1);

Local<String> statWatcherString =

FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher");

t->SetClassName(statWatcherString);

AsyncWrap::AddWrapMethods(env, t);

env->SetProtoMethod(t, "start", StatWatcher::Start);

env->SetProtoMethod(t, "stop", StatWatcher::Stop);

Local<FunctionTemplate> is_active_templ =

FunctionTemplate::New(env->isolate(),

IsActive,

env->as_external(),

Signature::New(env->isolate(), t));

t->PrototypeTemplate()->SetAccessorProperty(

FIXED_ONE_BYTE_STRING(env->isolate(), "isActive"),

is_active_templ,

Local<FunctionTemplate>(),

static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum));

target->Set(statWatcherString, t->GetFunction());

: AsyncWrap(env, wrap, AsyncWrap::PROVIDER_STATWATCHER),

watcher_(new uv_fs_poll_t) {

MakeWeak<StatWatcher>(this);

Wrap(wrap, this);

uv_fs_poll_init(env->event_loop(), watcher_);

watcher_->data = static_cast<void*>(this);

int status,

const uv_stat_t* prev,

const uv_stat_t* curr) {

StatWatcher* wrap = static_cast<StatWatcher*>(handle->data);

CHECK_EQ(wrap->watcher_, handle);

Environment* env = wrap->env();

HandleScope handle_scope(env->isolate());

Context::Scope context_scope(env->context());

node::FillGlobalStatsArray(env, curr);

node::FillGlobalStatsArray(env, prev, env->kFsStatsFieldsLength);

Local<Value> argv[2] {

Integer::New(env->isolate(), status),

env->fs_stats_field_array()->GetJSArray()

};

wrap->MakeCallback(env->onchange_string(), arraysize(argv), argv);

CHECK(args.IsConstructCall());

Environment* env = Environment::GetCurrent(args);

new StatWatcher(env, args.This());

StatWatcher* wrap = Unwrap<StatWatcher>(args.This());

CHECK(wrap != nullptr);

args.GetReturnValue().Set(wrap->IsActive());

CHECK_EQ(args.Length(), 3);

StatWatcher* wrap = Unwrap<StatWatcher>(args.Holder());

CHECK_NE(wrap, nullptr);

if (wrap->IsActive()) {

return;

}

const int argc = args.Length();

CHECK_GE(argc, 3);

node::Utf8Value path(args.GetIsolate(), args[0]);

CHECK_NE(*path, nullptr);

bool persistent = true;

if (args[1]->IsFalse()) {

persistent = false;

}

CHECK(args[2]->IsUint32());

const uint32_t interval = args[2].As<Uint32>()->Value();

// Safe, uv_ref/uv_unref are idempotent.

if (persistent)

uv_ref(reinterpret_cast<uv_handle_t*>(wrap->watcher_));

else

uv_unref(reinterpret_cast<uv_handle_t*>(wrap->watcher_));

// Note that uv_fs_poll_start does not return ENOENT, we are handling

// mostly memory errors here.

const int err = uv_fs_poll_start(wrap->watcher_, Callback, *path, interval);

if (err != 0) {

args.GetReturnValue().Set(err);

}

wrap->ClearWeak();

StatWatcher* wrap = Unwrap<StatWatcher>(args.Holder());

CHECK_NE(wrap, nullptr);

if (!wrap->IsActive()) {

return;

}

Environment* env = wrap->env();

Context::Scope context_scope(env->context());

wrap->MakeCallback(env->onstop_string(), 0, nullptr);

wrap->Stop();