Long live QDeadlineTimer

It's like QElapsedTimer, but marks a time in the future instead.

[ChangeLog][QtCore] Added QDeadlineTimer, a counterpart to
QElapsedTimer, used to mark a time point in the future (a deadline) and
determine whether such a deadline has passed.

Change-Id: Ifea6e497f11a461db432ffff144921f7fbc1d1d3
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 827 insertions, 0 deletions

diff --git a/src/corelib/kernel/qdeadlinetimer.cpp b/src/corelib/kernel/qdeadlinetimer.cpp
new file mode 100644
index 0000000000..7906b29ece
--- /dev/null
+++ b/src/corelib/kernel/qdeadlinetimer.cpp
@@ -0,0 +1,827 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdeadlinetimer.h"
+#include "qdeadlinetimer_p.h"
+#include <qpair.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_DECL_CONST_FUNCTION static inline QPair<qint64, qint64> toSecsAndNSecs(qint64 nsecs)
+{
+    qint64 secs = nsecs / (1000*1000*1000);
+    if (nsecs < 0)
+        --secs;
+    nsecs -= secs * 1000*1000*1000;
+    return qMakePair(secs, nsecs);
+}
+
+/*!
+    \class QDeadlineTimer
+    \inmodule QtCore
+    \brief The QDeadlineTimer class marks a deadline in the future.
+    \since 5.8
+
+    \reentrant
+    \ingroup tools
+
+    The QDeadlineTimer class is usually used to calculate future deadlines and
+    verify whether the deadline has expired. QDeadlineTimer can also be used
+    for deadlines without expiration ("forever"). It forms a counterpart to
+    QElapsedTimer, which calculates how much time has elapsed since
+    QElapsedTimer::start() was called.
+
+    QDeadlineTimer provides a more convenient API compared to
+    QElapsedTimer::hasExpired().
+
+    The typical use-case for the class is to create a QDeadlineTimer before the
+    operation in question is started, and then use remainingTime() or
+    hasExpired() to determine whether to continue trying the operation.
+    QDeadlineTimer objects can be passed to functions being called to execute
+    this operation so they know how long to still operate.
+
+    \code
+    void executeOperation(int msecs)
+    {
+        QDeadlineTimer deadline(msecs);
+        do {
+            if (readFromDevice(deadline.remainingTime())
+                break;
+            waitForReadyRead(deadline);
+        } while (!deadline.hasExpired());
+    }
+    \endcode
+
+    Many QDeadlineTimer functions deal with time out values, which all are
+    measured in milliseconds. There are two special values, the same as many
+    other Qt functions named \c{waitFor} or similar:
+
+    \list
+      \o 0: no time left, expired
+      \o -1: infinite time left, timer never expires
+    \endlist
+
+    \section1 Reference Clocks
+
+    QDeadlineTimer will use the same clock as QElapsedTimer (see
+    QElapsedTimer::clockType() and QElapsedTimer::isMonotonic()).
+
+    \section1 Timer types
+
+    Like QTimer, QDeadlineTimer can select among different levels of coarseness
+    on the timers. You can select precise timing by passing Qt::PreciseTimer to
+    the functions that set of change the timer, or you can select coarse timing
+    by passing Qt::CoarseTimer. Qt::VeryCoarseTimer is currently interpreted
+    the same way as Qt::CoarseTimer.
+
+    This feature is dependent on support from the operating system: if the OS
+    does not support a coarse timer functionality, then QDeadlineTimer will
+    behave like Qt::PreciseTimer was passed.
+
+    QDeadlineTimer defaults to Qt::CoarseTimer because on operating systems
+    that do support coarse timing, making timing calls to that clock source is
+    often much more efficient. The level of coarseness depends on the
+    operating system, but should be in the order of a couple of milliseconds.
+
+    \section1 \c{std::chrono} Compatibility
+
+    QDeadlineTimer is compatible with the \c{std::chrono} API from C++11 and
+    can be constructed from or compared to both \c{std::chrono::duration} and
+    \c{std::chrono::time_point} objects. In addition, it is fully compatible
+    with the time literals from C++14, which allow one to write code as:
+
+    \code
+        using namespace std::chrono;
+
+        QDeadlineTimer deadline(30s);
+        device->waitForReadyRead(deadline);
+        if (deadline.remainingTime<nanoseconds>() > 300ms)
+            cleanup();
+    \endcode
+
+    As can be seen in the example above, QDeadlineTimer offers a templated
+    version of remainingTime() and deadline() that can be used to return
+    \c{std::chrono} objects.
+
+    Note that comparing to \c{time_point} is not as efficient as comparing to
+    \c{duration}, since QDeadlineTimer may need to convert from its own
+    internal clock source to the clock source used by the \c{time_point} object.
+    Also note that, due to this conversion, the deadlines will not be precise,
+    so the following code is not expected to compare equally:
+
+    \code
+        using namespace std::chrono;
+        auto now = steady_clock::now();
+        QDeadlineTimer deadline(now + 1s);
+        Q_ASSERT(deadline == now + 1s);
+    \endcode
+
+    \sa QTime, QTimer, QDeadlineTimer, Qt::TimerType
+*/
+
+/*!
+    \enum QDeadlineTimer::ForeverConstant
+
+    \value Forever      Used when creating a QDeadlineTimer to indicate the
+                        deadline should not expire
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(Qt::TimerType timerType)
+
+    Constructs an expired QDeadlineTimer object. For this object,
+    remainingTime() will return 0.
+
+    The timer type \a timerType may be ignored, since the timer is already
+    expired. Similarly, for optimization purposes, this function will not
+    attempt to obtain the current time and will use a value known to be in the
+    past. Therefore, deadline() may return an unexpected value and this object
+    cannot be used in calculation of how long it is overdue. If that
+    functionality is required, use QDeadlineTimer::current().
+
+    \sa hasExpired(), remainingTime(), timerType(), current()
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(ForeverConstant, Qt::TimerType timerType)
+
+    Constructs a QDeadlineTimer object that never expires. For this object,
+    remainingTime() will return -1, deadline() will return the maximum value,
+    and isForever() will return true.
+
+    The timer type \a timerType may be ignored, since the timer is already
+    expired.
+
+    \sa hasExpired(), isForever(), remainingTime(), timerType()
+*/
+
+/*!
+    Constructs a QDeadlineTimer object with an expiry time of \a msecs msecs
+    from the moment of the creation of this object, if msecs is positive. If \a
+    msecs is zero, this QDeadlineTimer will be marked as expired, causing
+    remainingTime() to return zero and deadline() to return an indeterminate
+    time point in the past. If \a msecs is -1, the timer will be set it to
+    never expire, causing remainingTime() to return -1 and deadline() to return
+    the maximum value.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    For optimization purposes, if \a msecs is zero, this function may skip
+    obtaining the current time and may instead use a value known to be in the
+    past. If that happens, deadline() may return an unexpected value and this
+    object cannot be used in calculation of how long it is overdue. If that
+    functionality is required, use QDeadlineTimer::current() and add time to
+    it.
+
+    \sa hasExpired(), isForever(), remainingTime(), setRemainingTime()
+*/
+QDeadlineTimer::QDeadlineTimer(qint64 msecs, Qt::TimerType type) Q_DECL_NOTHROW
+    : t2(0)
+{
+    setRemainingTime(msecs, type);
+}
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type)
+
+    Constructs a QDeadlineTimer object with a deadline at \a deadline time
+    point, converting from the clock source \c{Clock} to Qt's internal clock
+    source (see QElapsedTimer::clcokType()).
+
+    If \a deadline is in the past, this QDeadlineTimer object is set to
+    expired, whereas if \a deadline is equal to \c{Duration::max()}, then this
+    object is set to never expire.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(), setDeadline()
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type)
+
+    Constructs a QDeadlineTimer object with a remaining time of \a remaining.
+    If \a remaining is zero or negative, this QDeadlineTimer object will be
+    mark as expired, whereas if \a remaining is equal to \c{duration::max()},
+    the object will be set to never expire.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    This constructor can be used with C++14's user-defined literals for time, such as in:
+
+    \code
+        using namespace std::chrono;
+        QDeadlineTimer deadline(250ms);
+    \endcode
+
+    For optimization purposes, if \a remaining is zero or negative, this
+    function may skip obtaining the current time and may instead use a value
+    known to be in the past. If that happens, deadline() may return an
+    unexpected value and this object cannot be used in calculation of how long
+    it is overdue. If that functionality is required, use
+    QDeadlineTimer::current() and add time to it.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(), setRemainingTime()
+*/
+
+/*!
+    \fn void QDeadlineTimer::setDeadline(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type)
+
+    Sets this QDeadlineTimer to the deadline marked by \a deadline time
+    point, converting from the clock source \c{Clock} to Qt's internal clock
+    source (see QElapsedTimer::clcokType()).
+
+    If \a deadline is in the past, this QDeadlineTimer object is set to
+    expired, whereas if \a deadline is equal to \c{Duration::max()}, then this
+    object is set to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(),
+*/
+
+/*!
+    Sets the remaining time for this QDeadlineTimer object to \a msecs
+    milliseconds from now, if \a msecs has a positive value. If \a msecs is
+    zero, this QDeadlineTimer object will be marked as expired, whereas a value
+    of -1 will set it to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setPreciseRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+void QDeadlineTimer::setRemainingTime(qint64 msecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (msecs == -1)
+        *this = QDeadlineTimer(Forever, timerType);
+    else
+        setPreciseRemainingTime(0, msecs * 1000 * 1000, timerType);
+}
+
+/*!
+    Sets the remaining time for this QDeadlineTimer object to \a secs seconds
+    plus \a nsecs nanoseconds from now, if \a secs has a positive value. If \a
+    secs is -1, this QDeadlineTimer will be set it to never expire. If both
+    parameters are zero, this QDeadlineTimer will be marked as expired.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, qint64 nsecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (secs == -1) {
+        *this = QDeadlineTimer(Forever, timerType);
+        return;
+    }
+
+    *this = current(timerType);
+    if (QDeadlineTimerNanosecondsInT2) {
+        t1 += secs + toSecsAndNSecs(nsecs).first;
+        t2 += toSecsAndNSecs(nsecs).second;
+        if (t2 > 1000*1000*1000) {
+            t2 -= 1000*1000*1000;
+            ++t1;
+        }
+    } else {
+        t1 += secs * 1000 * 1000 * 1000 + nsecs;
+    }
+}
+
+/*!
+    \overload
+    \fn void QDeadlineTimer::setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type)
+
+    Sets the remaining time for this QDeadlineTimer object to \a remaining. If
+    \a remaining is zero or negative, this QDeadlineTimer object will be mark
+    as expired, whereas if \a remaining is equal to \c{duration::max()}, the
+    object will be set to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    This function can be used with C++14's user-defined literals for time, such as in:
+
+    \code
+        using namespace std::chrono;
+        deadline.setRemainingTime(250ms);
+    \endcode
+
+    \sa setDeadline(), remainingTime<Duration>(), hasExpired(), isForever()
+*/
+
+/*!
+    \fn void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, unsigned nsecs, Qt::TimerType type)
+
+    Sets the remaining time for this QDeadlineTimer object to \a secs seconds
+    and \a nsecs nanoseconds from now, if \a secs is a positive value. If both
+    values are zero, this QDeadlineTimer object will be marked as expired,
+    whereas if \a secs is -1, it will set it to never expire.
+
+    If value of \a nsecs is more than 1 billion nanoseconds (1 second), this
+    function will adjust \a secs accordingly.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+
+/*!
+    \overload
+    \fn Duration QDeadlineTimer::remainingTime() const
+
+    Returns a \c{std::chrono::duration} object of type \c{Duration} containing
+    the remaining time in this QDeadlineTimer, if it still has time left. If
+    the deadline has passed, this returns \c{Duration::zero()}, whereas if the
+    object is set to never expire, it returns \c{Duration::max()} (instead of
+    -1).
+
+    It is not possible to obtain the overdue time for expired timers with this
+    function. To do that, see deadline().
+
+    \note The overload of this function without template parameter always
+    returns milliseconds.
+
+    \sa setRemainingTime(), deadline<Clock, Duration>()
+*/
+
+/*!
+    \overload
+    \fn std::chrono::time_point<Clock, Duration> QDeadlineTimer::deadline() const
+
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object as a \c{std::chrono::time_point} object. The template parameter
+    \c{Clock} is mandatory and indicates which of the C++ timekeeping clocks to
+    use as a reference. The value will be in the past if this QDeadlineTimer
+    has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::chrono::time_point<Clock, Duration>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting the current time point of the reference clock, as
+    in the following example:
+
+    \code
+        auto realTimeLeft = std::chrono::nanoseconds::max();
+        auto tp = deadline.deadline<std::chrono::steady_clock>();
+        if (tp != std::chrono::steady_clock::max())
+            realTimeLeft = tp - std::chrono::steady_clock::now();
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs(), setDeadline()
+*/
+
+/*!
+    Returns true if this QDeadlineTimer object never expires, false otherwise.
+    For timers that never expire, remainingTime() always returns -1 and
+    deadline() returns the maximum value.
+
+    \sa ForeverConstant, hasExpired(), remainingTime()
+*/
+bool QDeadlineTimer::isForever() const Q_DECL_NOTHROW
+{
+    return t1 == (std::numeric_limits<qint64>::max)();
+}
+
+/*!
+    Returns true if this QDeadlineTimer object has expired, false if there
+    remains time left. For objects that have expired, remainingTime() will
+    return zero and deadline() will return a time point in the past.
+
+    QDeadlineTimer objects created with the \ref{ForeverConstant} never expire
+    and this function always returns false for them.
+
+    \sa isForever(), remainingTime()
+*/
+bool QDeadlineTimer::hasExpired() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return false;
+    return *this <= current(timerType());
+}
+
+/*!
+    \fn Qt::TimerType QDeadlineTimer::timerType() const Q_DECL_NOTHROW
+
+    Returns the timer type is active for this object.
+
+    \sa setTimerType()
+*/
+
+/*!
+    Changes the timer type for this object to \a timerType.
+
+    The behavior for each possible value of \a timerType is operating-system
+    dependent. Qt::PreciseTimer will use the most precise timer that Qt can
+    find, with resolution of 1 millisecond or better, whereas QDeadlineTimer
+    will try to use a more coarse timer for Qt::CoarseTimer and
+    Qt::VeryCoarseTimer.
+
+    \sa timerType()
+ */
+void QDeadlineTimer::setTimerType(Qt::TimerType timerType)
+{
+    type = timerType;
+}
+
+/*!
+    Returns the remaining time in this QDeadlineTimer object in milliseconds.
+    If the timer has already expired, this function will return zero and it is
+    not possible to obtain the amount of time overdue with this function (to do
+    that, see deadline()). If the timer was set to never expire, this function
+    returns -1.
+
+    This function is suitable for use in Qt APIs that take a millisecond
+    timeout, such as the many \ref QIODevice \c waitFor functions or the timed
+    lock functions in \ref QMutex, \ref QWaitCondition, \ref QSemaphore, or
+    \ref QReadWriteLock. For example:
+
+    \code
+        mutex.tryLock(deadline.remainingTime());
+    \code
+
+    \sa remainingTimeNSecs(), isForever(), hasExpired()
+*/
+qint64 QDeadlineTimer::remainingTime() const Q_DECL_NOTHROW
+{
+    qint64 ns = remainingTimeNSecs();
+    return ns <= 0 ? ns : ns / (1000 * 1000);
+}
+
+/*!
+    Returns the remaining time in this QDeadlineTimer object in nanoseconds. If
+    the timer has already expired, this function will return zero and it is not
+    possible to obtain the amount of time overdue with this function. If the
+    timer was set to never expire, this function returns -1.
+
+    \sa remainingTime(), isForever(), hasExpired()
+*/
+qint64 QDeadlineTimer::remainingTimeNSecs() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return -1;
+    qint64 raw = rawRemainingTimeNSecs();
+    return raw < 0 ? 0 : raw;
+}
+
+/*!
+    \internal
+    Same as remainingTimeNSecs, but may return negative remaining times. Does
+    not deal with Forever.
+*/
+qint64 QDeadlineTimer::rawRemainingTimeNSecs() const Q_DECL_NOTHROW
+{
+    QDeadlineTimer now = current(timerType());
+    if (QDeadlineTimerNanosecondsInT2)
+        return (t1 - now.t1) * (1000*1000*1000) + t2 - now.t2;
+    return t1 - now.t1;
+}
+
+/*!
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object, calculated in milliseconds relative to the reference clock, the
+    same as QElapsedTimer::msecsSinceReference(). The value will be in the past
+    if this QDeadlineTimer has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::numeric_limits<qint64>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting QDeadlineTimer::current() or
+    QElapsedTimer::msecsSinceReference(), as in the following example:
+
+    \code
+        qint64 realTimeLeft = deadline.deadline();
+        if (realTimeLeft != (std::numeric_limits<qint64>::max)()) {
+            realTimeLeft -= QDeadlineTimer::current().deadline();
+            // or:
+            //QElapsedTimer timer;
+            //timer.start();
+            //realTimeLeft -= timer.msecsSinceReference();
+        }
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs(), setDeadline()
+*/
+qint64 QDeadlineTimer::deadline() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return t1;
+    return deadlineNSecs() / (1000 * 1000);
+}
+
+/*!
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object, calculated in nanoseconds relative to the reference clock, the
+    same as QElapsedTimer::msecsSinceReference(). The value will be in the past
+    if this QDeadlineTimer has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::numeric_limits<qint64>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting QDeadlineTimer::current(), as in the following
+    example:
+
+    \code
+        qint64 realTimeLeft = deadline.deadlineNSecs();
+        if (realTimeLeft != std::numeric_limits<qint64>::max())
+            realTimeLeft -= QDeadlineTimer::current().deadlineNSecs();
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs()
+*/
+qint64 QDeadlineTimer::deadlineNSecs() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return t1;
+    if (QDeadlineTimerNanosecondsInT2)
+        return t1 * 1000 * 1000 * 1000 + t2;
+    return t1;
+}
+
+/*!
+    Sets the deadline for this QDeadlineTimer object to be the \a msecs
+    absolute time point, counted in milliseconds since the reference clock (the
+    same as QElapsedTimer::msecsSinceReference()), and the timer type to \a
+    timerType. If the value is in the past, this QDeadlineTimer will be marked
+    as expired.
+
+    If \a msecs is \c{std::numeric_limits<qint64>::max()}, this QDeadlineTimer
+    will be set to never expire.
+
+    \sa setPreciseDeadline(), deadline(), deadlineNSecs(), setRemainingTime()
+*/
+void QDeadlineTimer::setDeadline(qint64 msecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (msecs == (std::numeric_limits<qint64>::max)()) {
+        setPreciseDeadline(msecs, 0, timerType);    // msecs == MAX implies Forever
+    } else {
+        setPreciseDeadline(msecs / 1000, msecs % 1000 * 1000 * 1000, timerType);
+    }
+}
+
+/*!
+    Sets the deadline for this QDeadlineTimer object to be \a secs seconds and
+    \a nsecs nanoseconds since the reference clock epoch (the same as
+    QElapsedTimer::msecsSinceReference()), and the timer type to \a timerType.
+    If the value is in the past, this QDeadlineTimer will be marked as expired.
+
+    If \a secs or \a nsecs is \c{std::numeric_limits<qint64>::max()}, this
+    QDeadlineTimer will be set to never expire. If \a nsecs is more than 1
+    billion nanoseconds (1 second), then \a secs will be adjusted accordingly.
+
+    \sa setDeadline(), deadline(), deadlineNSecs(), setRemainingTime()
+*/
+void QDeadlineTimer::setPreciseDeadline(qint64 secs, qint64 nsecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    type = timerType;
+    if (secs == (std::numeric_limits<qint64>::max)() || nsecs == (std::numeric_limits<qint64>::max)()) {
+        *this = QDeadlineTimer(Forever, timerType);
+    } else if (QDeadlineTimerNanosecondsInT2) {
+        t1 = secs + toSecsAndNSecs(nsecs).first;
+        t2 = toSecsAndNSecs(nsecs).second;
+    } else {
+        t1 = secs * (1000*1000*1000) + nsecs;
+    }
+}
+
+/*!
+    Returns a QDeadlineTimer object whose deadline is extended from \a dt's
+    deadline by \a nsecs nanoseconds. If \a dt was set to never expire, this
+    function returns a QDeadlineTimer that will not expire either.
+
+    \note if \a dt was created as expired, its deadline is indeterminate and
+    adding an amount of time may or may not cause it to become unexpired.
+*/
+QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs) Q_DECL_NOTHROW
+{
+    if (dt.isForever() || nsecs == (std::numeric_limits<qint64>::max)()) {
+        dt = QDeadlineTimer(Forever, dt.timerType());
+    } else if (QDeadlineTimerNanosecondsInT2) {
+        dt.t1 += toSecsAndNSecs(nsecs).first;
+        dt.t2 += toSecsAndNSecs(nsecs).second;
+        if (dt.t2 > 1000*1000*1000) {
+            dt.t2 -= 1000*1000*1000;
+            ++dt.t1;
+        }
+    } else {
+        dt.t1 += nsecs;
+    }
+    return dt;
+}
+
+/*!
+    \fn QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType)
+
+    Returns a QDeadlineTimer that is expired but is guaranteed to contain the
+    current time. Objects created by this function can participate in the
+    calculation of how long a timer is overdue, using the deadline() function.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+*/
+
+/*!
+    \fn qint64 QDeadlineTimer::resolution(Qt::TimerType timerType)
+
+    Returns the resolution in nanoseconds of the system clock that backs timers
+    of type \a timerType, or 0 if the resolution could not be determined.
+
+    The resolution is not a guarantee that applications will get time values
+    with an accuracy down to that level. It is only the minimum change value
+    that can be expected.
+*/
+
+/*!
+    \fn bool operator==(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 and the deadline in \a d2 are the
+    same, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() == d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator!=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 and the deadline in \a d2 are
+    diferent, false otherwise. The timer type used to create the two deadlines
+    is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() != d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator<(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is earlier than the deadline in \a
+    d2, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() < d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator<=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is earlier than or the same as the
+    deadline in \a d2, false otherwise. The timer type used to create the two
+    deadlines is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() <= d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator>(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is later than the deadline in \a
+    d2, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() > d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator>=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is later than or the same as the
+    deadline in \a d2, false otherwise. The timer type used to create the two
+    deadlines is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() >= d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs later than the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs later than the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs before the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To subtract times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer &QDeadlineTimer::operator+=(qint64 msecs)
+
+    Extends this QDeadlineTimer object by \a msecs milliseconds and returns
+    itself. If this object is set to never expire, this function does nothing.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer &QDeadlineTimer::operator-=(qint64 msecs)
+
+    Shortens this QDeadlineTimer object by \a msecs milliseconds and returns
+    itself. If this object is set to never expire, this function does nothing.
+
+    To subtract times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+// the rest of the functions are in qelapsedtimer_xxx.cpp
+
+QT_END_NAMESPACE