const v8::Local<v8::Context>& ctx) {

double value = -1;

if (v->IsNullOrUndefined()) {

return -1;

}

Local<Number> numberValue;

auto success = v->ToNumber(ctx).ToLocal(&numberValue);

if (success) {

value = numberValue->Value();

if (isnan(value)) {

value = -1;

}

}

return value;

struct timespec res;

clock_gettime(CLOCK_MONOTONIC, &res);

return 1000.0 * res.tv_sec + (double)res.tv_nsec / 1e6;

public:

std::mutex timerMutex_;

std::atomic<int> currentTimerId = 0;

robin_hood::unordered_map<int, std::shared_ptr<TimerTask>> timerMap_;

CFRunLoopRef runloop;

void removeTask(const std::shared_ptr<TimerTask>& task) {

removeTask(task->id_);

}

void removeTask(const int& taskId) {

auto it = timerMap_.find(taskId);

if (it != timerMap_.end()) {

// auto wasScheduled = it->second->queued_;

auto timer = it->second->timer;

it->second->Unschedule();

timerMap_.erase(it);

CFRunLoopTimerInvalidate(timer);

// CFRunLoopTimerInvalidate triggers our TimerRelease callback, which

// deletes TimerContext, whose destructor calls CFRelease(task->timer)

}

}

// this all comes from the android runtime implementation

void addTask(std::shared_ptr<TimerTask> task) {

if (task->queued_) {

return;

}

// auto now = now_ms();

// task->nestingLevel_ = nesting + 1;

task->queued_ = true;

// theoretically this should be >5 on the spec, but we're following chromium

// behavior here again

// if (task->nestingLevel_ >= 5 && task->frequency_ < 4) {

// task->frequency_ = 4;

// task->startTime_ = now;

// }

timerMap_.emplace(task->id_, task);

// not needed on the iOS runtime for now

// auto newTime = task->NextTime(now);

// task->dueTime_ = newTime;

}

public:

std::atomic<int> retainCount{0};

std::shared_ptr<TimerTask> task;

TimerState* state;

~TimerContext() {

task->Unschedule();

CFRelease(task->timer);

}

static const void* TimerRetain(const void* ret) {

auto v = (TimerContext*)(ret);

v->retainCount++;

return ret;

}

static void TimerRelease(const void* ret) {

auto v = (TimerContext*)(ret);

if (--v->retainCount <= 0) {

delete v;

};

}

auto timerState = new TimerState();

timerState->runloop = Runtime::GetRuntime(isolate)->RuntimeLoop();

Caches::Get(isolate)->registerCacheBoundObject(timerState);

tns::NewFunctionTemplate(isolate, Timers::SetTimeoutCallback,

v8::External::New(isolate, timerState));

tns::SetMethod(isolate, globalTemplate, "__ns__setTimeout",

Timers::SetTimeoutCallback,

v8::External::New(isolate, timerState));

tns::SetMethod(isolate, globalTemplate, "__ns__setInterval",

Timers::SetIntervalCallback,

v8::External::New(isolate, timerState));

tns::SetMethod(isolate, globalTemplate, "__ns__clearTimeout",

Timers::ClearTimeoutCallback,

v8::External::New(isolate, timerState));

tns::SetMethod(isolate, globalTemplate, "__ns__clearInterval",

Timers::ClearTimeoutCallback,

v8::External::New(isolate, timerState));

Caches::Get(isolate)->registerCacheBoundObject(new TimerState());

TimerContext* data = (TimerContext*)info;

auto task = data->task;

// we check for this first so we can be 100% sure that this task is still

// alive since we're always dealing with the runtime's runloop, it should

// always work if we even support firing the timers in a another runloop, then

// this is useful as it'll avoid use-after-free issues

if (!task->queued_ || !task->wrapper.IsValid()) {

return;

}

auto isolate = task->isolate_;

v8::Locker locker(isolate);

v8::Isolate::Scope isolate_scope(isolate);

v8::HandleScope handleScope(isolate);

// ensure we're still queued after locking

if (!task->queued_) {

return;

}

v8::Local<v8::Function> cb = task->callback_.Get(isolate);

v8::Local<v8::Context> context = cb->GetCreationContextChecked();

Context::Scope context_scope(context);

int argc = task->args_ ? static_cast<int>(task->args_->size()) : 0;

if (argc > 0) {

// allocate an array of the right size

std::vector<Local<Value>> argv(argc);

for (int i = 0; i < argc; ++i) {

argv[i] = task->args_->at(i)->Get(isolate);

}

// pass pointer to the first element

(void)cb->Call(context, context->Global(), argc, argv.data());

} else {

(void)cb->Call(context, context->Global(), 0, nullptr);

}

if (!task->repeats_) {

data->state->removeTask(task);

}

bool repeatable) {

auto argLength = args.Length();

auto extData = args.Data().As<External>();

TimerState* state = reinterpret_cast<TimerState*>(extData->Value());

int id = ++state->currentTimerId;

if (argLength >= 1) {

if (!args[0]->IsFunction()) {

args.GetReturnValue().Set(-1);

return;

}

auto handler = args[0].As<v8::Function>();

auto isolate = args.GetIsolate();

auto ctx = isolate->GetCurrentContext();

long timeout = 0;

if (argLength >= 2) {

timeout = (long)ToMaybePositiveValue(args[1], ctx);

if (timeout < 0) {

timeout = 0;

}

}

std::shared_ptr<std::vector<std::shared_ptr<Persistent<Value>>>> argArray;

if (argLength >= 3) {

auto otherArgLength = argLength - 2;

argArray =

std::make_shared<std::vector<std::shared_ptr<Persistent<Value>>>>(

otherArgLength);

for (int i = 0; i < otherArgLength; i++) {

(*argArray)[i] =

std::make_shared<Persistent<Value>>(isolate, args[i + 2]);

#ifdef DEBUG

(*argArray)[i]->AnnotateStrongRetainer("timer_argument");

#endif

}

}

auto task = std::make_shared<TimerTask>(isolate, handler, timeout,

repeatable, argArray, id, now_ms());

#ifdef DEBUG

task->callback_.AnnotateStrongRetainer("timer");

#endif

task->repeats_ = repeatable;

CFRunLoopTimerContext timerContext = {0, NULL, NULL, NULL, NULL};

auto timerData = new TimerContext();

timerData->task = task;

timerData->state = state;

timerContext.info = timerData;

timerContext.retain = TimerContext::TimerRetain;

timerContext.release = TimerContext::TimerRelease;

// we do this because the timer should take hold of exactly 1 retaincount

// after scheduling so if by our manual release the retain is 0 then we need

// to cleanup the TimerContext

TimerContext::TimerRetain(timerData);

// timeout should be bigger than 0 if it's repeatable and 0

auto timeoutInSeconds =

repeatable && timeout == 0 ? 0.0000001f : timeout / 1000.f;

auto timer = CFRunLoopTimerCreate(

kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + timeoutInSeconds,

repeatable ? timeoutInSeconds : 0, 0, 0, TimerCallback, &timerContext);

state->addTask(task);

// set the actual timer we created

task->timer = timer;

CFRunLoopAddTimer(state->runloop, timer, kCFRunLoopCommonModes);

TimerContext::TimerRelease(timerData);

// auto task = std::make_shared<TimerTask>(isolate, handler, timeout,

// repeatable,

// argArray, id, now_ms());

// thiz->addTask(task);

}

args.GetReturnValue().Set(id);

const v8::FunctionCallbackInfo<v8::Value>& args) {

auto argLength = args.Length();

auto extData = args.Data().As<External>();

auto thiz = reinterpret_cast<TimerState*>(extData->Value());

int id = -1;

if (argLength > 0) {

auto isolate = args.GetIsolate();

auto ctx = isolate->GetCurrentContext();

id = (int)ToMaybePositiveValue(args[0], ctx);

}

// ids start at 1

if (id > 0) {

thiz->removeTask(id);

}