/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #include "uv.h" #include "internal.h" #include #include static int uv__timer_cmp(const uv_timer_t* a, const uv_timer_t* b) { if (a->timeout < b->timeout) return -1; if (a->timeout > b->timeout) return 1; /* * compare start_id when both has the same timeout. start_id is * allocated with loop->timer_counter in uv_timer_start(). */ if (a->start_id < b->start_id) return -1; if (a->start_id > b->start_id) return 1; return 0; } RB_GENERATE_STATIC(uv__timers, uv_timer_s, tree_entry, uv__timer_cmp) int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) { uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER); handle->timer_cb = NULL; handle->repeat = 0; return 0; } int uv_timer_start(uv_timer_t* handle, uv_timer_cb cb, uint64_t timeout, uint64_t repeat) { uint64_t clamped_timeout; if (uv__is_active(handle)) uv_timer_stop(handle); clamped_timeout = handle->loop->time + timeout; if (clamped_timeout < timeout) clamped_timeout = (uint64_t) -1; handle->timer_cb = cb; handle->timeout = clamped_timeout; handle->repeat = repeat; /* start_id is the second index to be compared in uv__timer_cmp() */ handle->start_id = handle->loop->timer_counter++; RB_INSERT(uv__timers, &handle->loop->timer_handles, handle); uv__handle_start(handle); return 0; } int uv_timer_stop(uv_timer_t* handle) { if (!uv__is_active(handle)) return 0; RB_REMOVE(uv__timers, &handle->loop->timer_handles, handle); uv__handle_stop(handle); return 0; } int uv_timer_again(uv_timer_t* handle) { if (handle->timer_cb == NULL) return -EINVAL; if (handle->repeat) { uv_timer_stop(handle); uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat); } return 0; } void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) { handle->repeat = repeat; } uint64_t uv_timer_get_repeat(const uv_timer_t* handle) { return handle->repeat; } int uv__next_timeout(const uv_loop_t* loop) { const uv_timer_t* handle; uint64_t diff; /* RB_MIN expects a non-const tree root. That's okay, it doesn't modify it. */ handle = RB_MIN(uv__timers, (struct uv__timers*) &loop->timer_handles); if (handle == NULL) return -1; /* block indefinitely */ if (handle->timeout <= loop->time) return 0; diff = handle->timeout - loop->time; if (diff > INT_MAX) diff = INT_MAX; return diff; } void uv__run_timers(uv_loop_t* loop) { uv_timer_t* handle; while ((handle = RB_MIN(uv__timers, &loop->timer_handles))) { if (handle->timeout > loop->time) break; uv_timer_stop(handle); uv_timer_again(handle); handle->timer_cb(handle, 0); } } void uv__timer_close(uv_timer_t* handle) { uv_timer_stop(handle); }