qdeadlinetimer.cpp

Go to the documentation of this file.

// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdeadlinetimer.h"
#include "private/qnumeric_p.h"
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QDeadlineTimer)
 
using namespace std::chrono;
 
namespace {
struct TimeReference : std::numeric_limits<qint64>
{
    static constexpr qint64 Min = min();
    static constexpr qint64 Max = max();
};
}
 
template <typename Duration1, typename... Durations>
static qint64 add_saturate(qint64 t1, Duration1 dur, Durations... extra)
{
    qint64 v = dur.count();
    qint64 saturated = std::numeric_limits<qint64>::max();
    if (v < 0)
        saturated = std::numeric_limits<qint64>::min();
 
    // convert to nanoseconds with saturation
    using Ratio = std::ratio_divide<typename Duration1::period, nanoseconds::period>;
    static_assert(Ratio::den == 1, "sub-multiples of nanosecond are not supported");
    if (qMulOverflow<Ratio::num>(v, &v))
        return saturated;
 
    qint64 r;
    if (qAddOverflow(t1, v, &r))
        return saturated;
    if constexpr (sizeof...(Durations)) {
        // chain more additions
        return add_saturate(r, extra...);
    }
    return r;
}
 
QDeadlineTimer::QDeadlineTimer(qint64 msecs, Qt::TimerType type) noexcept
{
    setRemainingTime(msecs, type);
}
 
void QDeadlineTimer::setRemainingTime(qint64 msecs, Qt::TimerType timerType) noexcept
{
    if (msecs < 0) {
        *this = QDeadlineTimer(Forever, timerType);
    } else if (msecs == 0) {
        *this = QDeadlineTimer(timerType);
        t1 = std::numeric_limits<qint64>::min();
    } else {
        *this = current(timerType);
        milliseconds ms(msecs);
        t1 = add_saturate(t1, ms);
    }
}
 
void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, qint64 nsecs, Qt::TimerType timerType) noexcept
{
    if (secs < 0) {
        *this = QDeadlineTimer(Forever, timerType);
    } else if (secs == 0 && nsecs == 0) {
        *this = QDeadlineTimer(timerType);
        t1 = std::numeric_limits<qint64>::min();
    } else {
        *this = current(timerType);
        t1 = add_saturate(t1, seconds{secs}, nanoseconds{nsecs});
    }
}
 
bool QDeadlineTimer::hasExpired() const noexcept
{
    if (isForever())
        return false;
    if (t1 == std::numeric_limits<qint64>::min())
        return true;
    return *this <= current(timerType());
}
 
void QDeadlineTimer::setTimerType(Qt::TimerType timerType)
{
    type = timerType;
}
 
qint64 QDeadlineTimer::remainingTime() const noexcept
{
    if (isForever())
        return -1;
 
    nanoseconds nsecs(remainingTimeNSecs());
    return ceil<milliseconds>(nsecs).count();
}
 
qint64 QDeadlineTimer::remainingTimeNSecs() const noexcept
{
    if (isForever())
        return -1;
    qint64 raw = rawRemainingTimeNSecs();
    return raw < 0 ? 0 : raw;
}
 
qint64 QDeadlineTimer::rawRemainingTimeNSecs() const noexcept
{
    if (t1 == std::numeric_limits<qint64>::min())
        return t1;          // we'd saturate to this anyway
 
    QDeadlineTimer now = current(timerType());
    qint64 r;
    if (qSubOverflow(t1, now.t1, &r))
        return -1;      // any negative number is fine
    return r;
}
 
qint64 QDeadlineTimer::deadline() const noexcept
{
    if (isForever())
        return TimeReference::Max;
    if (t1 == TimeReference::Min)
        return t1;
 
    nanoseconds ns(t1);
    return duration_cast<milliseconds>(ns).count();
}
 
qint64 QDeadlineTimer::deadlineNSecs() const noexcept
{
    if (isForever())
        return TimeReference::Max;
 
    return t1;
}
 
void QDeadlineTimer::setDeadline(qint64 msecs, Qt::TimerType timerType) noexcept
{
    if (msecs == TimeReference::Max) {
        *this = QDeadlineTimer(Forever, timerType);
        return;
    }
 
    type = timerType;
    t1 = add_saturate(0, milliseconds{msecs});
}
 
void QDeadlineTimer::setPreciseDeadline(qint64 secs, qint64 nsecs, Qt::TimerType timerType) noexcept
{
    type = timerType;
    t1 = add_saturate(0, seconds{secs}, nanoseconds{nsecs});
}
 
QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs) noexcept
{
    if (dt.isForever())
        return dt;
 
    dt.t1 = add_saturate(dt.t1, nanoseconds{nsecs});
    return dt;
}
 
QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) noexcept
{
    // ensure we get nanoseconds; this will work so long as steady_clock's
    // time_point isn't of finer resolution (picoseconds)
    std::chrono::nanoseconds ns = std::chrono::steady_clock::now().time_since_epoch();
 
    QDeadlineTimer result;
    result.t1 = ns.count();
    result.type = timerType;
    return result;
}
 
QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)
{
    if (dt.isForever())
        return dt;
 
    dt.t1 = add_saturate(dt.t1, milliseconds{msecs});
    return dt;
}
 
QT_END_NAMESPACE