unsigned int startTimer(void *handle, char *sid, unsigned int duration, char *timer) {
void *rulesBinding;
unsigned int result = resolveBinding(handle, sid, &rulesBinding);
if (result != RULES_OK) {
return result;
}
return registerTimer(rulesBinding, duration, timer);
}
Timer::ptr
TimerManager::registerConditionTimer(unsigned long long us,
boost::function<void ()> dg,
boost::weak_ptr<void> weakCond,
bool recurring)
{
return registerTimer(us,
boost::bind(stubOnTimer, weakCond, dg),
recurring);
}
bool
SelfDrainingQueue::enqueue( ServiceData* data, bool allow_dups )
{
if( ! allow_dups ) {
SelfDrainingHashItem hash_item(data);
if( m_hash.insert(hash_item,true) == -1 ) {
dprintf( D_FULLDEBUG, "SelfDrainingQueue::enqueue() "
"refusing duplicate data\n" );
return false;
}
}
queue.enqueue(data);
dprintf( D_FULLDEBUG,
"Added data to SelfDrainingQueue %s, now has %d element(s)\n",
name, queue.Length() );
registerTimer();
return true;
}
// Test unsetting explicitDur
TEST_F( ImagePlayerExplicitDuration, unsetting_explicitDur ) {
ASSERT_TRUE ( _player->setProperty( "src", util::getImageName("red_100_100.jpg") ) );
ASSERT_TRUE ( _player->setProperty( "bounds", canvas::Rect(0,0,100,100) ) );
ASSERT_TRUE ( _player->setProperty( "explicitDur", 100 ) );
ASSERT_TRUE ( _player->play() );
ASSERT_TRUE ( _player->setProperty( "explicitDur", 0 ) );
ASSERT_TRUE ( util::compareImages( canvas(), getExpectedPath("before_finish") ) );
boost::condition_variable wakeup;
boost::mutex mutex;
boost::unique_lock<boost::mutex> lock( mutex );
registerTimer(300, boost::bind(&cb_wakeup, &wakeup));
wakeup.wait(lock);
// Assert that the player is still playing after 1000 ms beacuse the explicitDur was unsetted
ASSERT_TRUE ( util::compareImages( canvas(), getExpectedPath("before_finish") ) );
}
int
CheckIdleUserTask::start()
{
switch (m_CurrentState) {
case TASK_INIT: {
return registerTimer();
break;
}
default: {
// never going here
ERROR_LOG("unexpected state %d", m_CurrentState);
assert(0);
break;
}
}
return 0;
}
/*!
\fn int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
Registers a timer with the specified \a interval for the given \a object.
*/
int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
{
int id = QAbstractEventDispatcherPrivate::allocateTimerId();
registerTimer(id, interval, object);
return id;
}
TimerLibEvent::TimerLibEvent(struct event_base *base, size_t milliseconds, TimerHandler h, bool persist) : handler(h) {
ev = event_new(base, -1, persist ? EV_PERSIST : 0, ssle_timer_callback, this);
registerTimer(milliseconds);
}
void configureTimer(float modelBaseRate)
{int i = 0;
int setup;
setup = getSysTime(modelBaseRate);
i = registerTimer (modelBaseRate, model_step);
}
/*!
\fn int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
Registers a timer with the specified \a interval for the given \a object.
*/
int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)
{
int id = timerId.fetchAndAddRelaxed(1);
registerTimer(id, interval, object);
return id;
}
unsigned int EventLoop::exec(int timeoutTime)
{
int quitTimerId = -1;
if (timeoutTime != -1)
quitTimerId = registerTimer([=](int) { timeout = true; quit(); }, timeoutTime, Timer::SingleShot);
unsigned int ret = 0;
#if defined(HAVE_EPOLL) || defined(HAVE_KQUEUE)
enum { MaxEvents = 64 };
NativeEvent events[MaxEvents];
#endif
for (;;) {
for (;;) {
if (!sendPostedEvents() && !sendTimers())
break;
}
int waitUntil = -1;
{
std::lock_guard<std::mutex> locker(mutex);
// check if we're stopped
if (stop) {
stop = false;
if (timeout) {
timeout = false;
ret = Timeout;
} else {
ret = Success;
}
break;
}
const auto timer = timersByTime.begin();
if (timer != timersByTime.end()) {
const uint64_t now = currentTime();
waitUntil = std::max<int>((*timer)->when - now, 0);
}
}
int eventCount;
#if defined(HAVE_EPOLL)
eintrwrap(eventCount, epoll_wait(pollFd, events, MaxEvents, waitUntil));
#elif defined(HAVE_KQUEUE)
timespec timeout;
timespec* timeptr = 0;
if (waitUntil != -1) {
timeout.tv_sec = waitUntil / 1000;
timeout.tv_nsec = (waitUntil % 1000LLU) * 1000000;
timeptr = &timeout;
}
eintrwrap(eventCount, kevent(pollFd, 0, 0, events, MaxEvents, timeptr));
#elif defined(HAVE_SELECT)
timeval timeout;
timeval* timeptr = 0;
if (waitUntil != -1) {
timeout.tv_sec = waitUntil / 1000;
timeout.tv_usec = (waitUntil % 1000LLU) * 1000;
timeptr = &timeout;
}
fd_set rdfd, wrfd;
fd_set* wrfdp = 0;
FD_ZERO(&rdfd);
FD_ZERO(&wrfd);
int max = eventPipe[0];
FD_SET(max, &rdfd);
{
std::lock_guard<std::mutex> locker(mutex);
auto s = sockets.begin();
const auto e = sockets.end();
while (s != e) {
if (s->second.first & SocketRead) {
FD_SET(s->first, &rdfd);
}
if (s->second.first & SocketWrite) {
if (!wrfdp)
wrfdp = &wrfd;
FD_SET(s->first, wrfdp);
}
max = std::max(max, s->first);
++s;
}
}
eintrwrap(eventCount, select(max + 1, &rdfd, wrfdp, 0, timeptr));
#endif
if (eventCount < 0) {
// bad
ret = GeneralError;
break;
} else if (eventCount) {
#if defined(HAVE_SELECT)
NativeEvent event;
event.rdfd = &rdfd;
event.wrfd = wrfdp;
NativeEvent* events = &event;
#endif
ret = processSocketEvents(events, eventCount);
if (ret & (Success|GeneralError|Timeout))
break;
}
}
if (quitTimerId != -1)
clearTimer(quitTimerId);
return ret;
}
