TimeDelta unpackDelta(PackedDateTimeDelta delta)
{
auto days = int(delta / USECS_PER_DAY);
delta %= USECS_PER_DAY;
auto seconds = int(delta / USECS_PER_SEC);
return TimeDelta(days, seconds, delta % USECS_PER_SEC);
}
void MessagePumpLibevent::Run(Delegate* delegate) {
//DCHECK(keep_running_) << "Quit must have been called outside of Run!";
assert(keep_running_);
// event_base_loopexit() + EVLOOP_ONCE is leaky, see http://crbug.com/25641.
// Instead, make our own timer and reuse it on each call to event_base_loop().
std::unique_ptr<event> timer_event(new event);
for (;;) {
bool did_work = delegate->DoWork();
if (!keep_running_)
break;
event_base_loop(event_base_, EVLOOP_NONBLOCK);
did_work |= processed_io_events_;
processed_io_events_ = false;
if (!keep_running_)
break;
did_work |= delegate->DoDelayedWork(&delayed_work_time_);
if (!keep_running_)
break;
if (did_work)
continue;
did_work = delegate->DoIdleWork();
if (!keep_running_)
break;
if (did_work)
continue;
// EVLOOP_ONCE tells libevent to only block once,
// but to service all pending events when it wakes up.
if (delayed_work_time_.is_null()) {
event_base_loop(event_base_, EVLOOP_ONCE);
} else {
TimeDelta delay = delayed_work_time_ - TimeTicks::Now();
if (delay > TimeDelta()) {
struct timeval poll_tv;
poll_tv.tv_sec = (long)delay.InSeconds();
poll_tv.tv_usec = delay.InMicroseconds() % Time::kMicrosecondsPerSecond;
event_set(timer_event.get(), -1, 0, timer_callback, event_base_);
event_base_set(event_base_, timer_event.get());
event_add(timer_event.get(), &poll_tv);
event_base_loop(event_base_, EVLOOP_ONCE);
event_del(timer_event.get());
} else {
delayed_work_time_ = TimeTicks();
}
}
}
keep_running_ = true;
}
bool MessageLoopProxy::PostTaskHelper(
const StdClosure& task, TimeDelta delay, bool nestable)
{
NAutoLock lock(&message_loop_lock_);
if (target_message_loop_) {
if (nestable) {
if (delay == TimeDelta())
target_message_loop_->PostTask(task);
else
target_message_loop_->PostDelayedTask(task, delay);
} else {
if (delay == TimeDelta())
target_message_loop_->PostNonNestableTask(task);
else
target_message_loop_->PostNonNestableDelayedTask(task, delay);
}
return true;
}
return false;
}
TimeDelta getMJD( int ridx )
{
GUInt32 mjd[3] ;
if ( ridx < 0 ) ridx += nrec ;
EnvisatFile_ReadDatasetRecordChunk(&envfile,index,ridx,mjd,0,12) ;
#define INT32(x) ((GInt32)CPL_MSBWORD32(x))
return TimeDelta( INT32(mjd[0]), INT32(mjd[1]), INT32(mjd[2]) ) ;
#undef INT32
}
void DefaultMessagePump::Run(Delegate* delegate)
{
// Quit must have been called outside of Run!
assert(should_quit_ == false);
for (;;)
{
bool did_work = delegate->DoWork();
if (should_quit_)
break;
did_work |= delegate->DoDelayedWork(&delayed_work_time_);
if (should_quit_)
break;
if (did_work)
continue;
did_work = delegate->DoIdleWork();
if (should_quit_)
break;
if (did_work)
continue;
if (delayed_work_time_.is_null())
{
Wait();
}
else
{
TimeDelta delay = delayed_work_time_ - TimeTicks::Now();
if (delay > TimeDelta())
WaitTimeout(delay);
else
{
// It looks like delayed_work_time_ indicates a time in the past, so we
// need to call DoDelayedWork now.
delayed_work_time_ = TimeTicks();
}
}
}
should_quit_ = false;
}
TimeDelta operator/(const T &n) const {
return TimeDelta(delta_ / n);
}
TimeDelta operator*(const T &n) const {
return TimeDelta(delta_ * n);
}
TimeDelta operator-(const TimeDelta &other) const {
return TimeDelta(delta_ - other.delta_);
}
// static
inline TimeDelta TimeDelta::FromMicroseconds(int64_t us) {
return TimeDelta(us);
}
bool MessageLoopProxy::PostNonNestableTask(const StdClosure &task)
{
return PostTaskHelper(task, TimeDelta(), false);
}
// static
inline TimeDelta TimeDelta::FromSeconds(int64_t secs) {
return TimeDelta(secs * Time::kMicrosecondsPerSecond);
}
// static
inline TimeDelta TimeDelta::FromMinutes(int64_t minutes) {
return TimeDelta(minutes * Time::kMicrosecondsPerMinute);
}
// static
inline TimeDelta TimeDelta::FromHours(int64_t hours) {
return TimeDelta(hours * Time::kMicrosecondsPerHour);
}
// static
inline TimeDelta TimeDelta::FromDays(int64_t days) {
return TimeDelta(days * Time::kMicrosecondsPerDay);
}
TimeDelta Diff(const Time &other) const {
return TimeDelta(us_ - other.us_);
}
// static
inline TimeDelta TimeDelta::FromMilliseconds(int64_t ms) {
return TimeDelta(ms * Time::kMicrosecondsPerMillisecond);
}
void X11UIEventLoopImpl::waitForWork()
{
int fd = _engine->_fd;
int fdSize = Math::max(fd, _engine->_wakeUpPipe[0]) + 1;
fd_set fdSet;
struct timeval tval;
struct timeval* ptval = NULL;
FD_ZERO(&fdSet);
FD_SET(fd, &fdSet);
FD_SET(_engine->_wakeUpPipe[0], &fdSet);
if (_delayedWorkTime.isNull())
{
// There are no scheduled tasks, so ptval is NULL and this tells to select()
// that it should wait infinite time.
}
else
{
TimeDelta delay = _delayedWorkTime - Time::now();
if (delay > TimeDelta())
{
// Go to sleep. X11 will wake us to process X events and we also set
// interval to wake up to run planned tasks (usually Timers).
int64_t udelay = delay.getMicroseconds();
tval.tv_sec = (int)(udelay / 1000000);
tval.tv_usec = (int)(udelay % 1000000);
if (tval.tv_usec <= 100) tval.tv_usec = 100;
ptval = &tval;
}
else
{
// It looks like delayedWorkTime indicates a time in the past, so we
// need to call doDelayedWork now.
_delayedWorkTime = Time();
return;
}
}
int ret = ::select(fdSize, &fdSet, NULL, NULL, ptval);
if (ret < 0)
{
Logger::error("Fog::X11UIEventLoopImpl", "waitForWork", "Failed to call select(), errno=%d.", errno);
}
if (ret > 0)
{
if (FD_ISSET(_engine->_wakeUpPipe[0], &fdSet))
{
// Dummy c, the actual value is out of our interest.
char c;
if (::read(_engine->_wakeUpPipe[0], &c, sizeof(char)) != sizeof(char))
{
Logger::error("Fog::X11UIEventLoopImpl", "waitForWork()", "Failed to read from wake-up pipe.");
}
_wakeUpSent.cmpXchg(1, 0);
}
}
}
bool MessageLoopProxy::PostTask(const StdClosure &task)
{
return PostTaskHelper(task, TimeDelta(), true);
}
