QDeadlineTimer¶

The QDeadlineTimer class marks a deadline in the future. More…

New in version 5.8.

Synopsis¶

Functions¶

def __add__ (msecs)
def __eq__ (d2)
def __ge__ (d2)
def __gt__ (d2)
def __iadd__ (msecs)
def __isub__ (msecs)
def __le__ (d2)
def __lt__ (d2)
def __ne__ (d2)
def __sub__ (dt2)
def __sub__ (msecs)
def _q_data ()
def deadline ()
def deadlineNSecs ()
def hasExpired ()
def isForever ()
def remainingTime ()
def remainingTimeNSecs ()
def setDeadline (msecs[, timerType=Qt.CoarseTimer])
def setPreciseDeadline (secs[, nsecs=0[, type=Qt.CoarseTimer]])
def setPreciseRemainingTime (secs[, nsecs=0[, type=Qt.CoarseTimer]])
def setRemainingTime (msecs[, type=Qt.CoarseTimer])
def setTimerType (type)
def swap (other)
def timerType ()

Static functions¶

def addNSecs (dt, nsecs)
def current ([timerType=Qt.CoarseTimer])

Detailed Description¶

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 start() was called.

QDeadlineTimer provides a more convenient API compared to 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.

def executeOperation(msecs):

    deadline = QDeadlineTimer(msecs)
    do {
        if (readFromDevice(deadline.remainingTime()))
            break
        waitForReadyRead(deadline)
    } while (not deadline.hasExpired())

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 waitFor or similar:

0: no time left, expired

-1: infinite time left, timer never expires

Reference Clocks¶

QDeadlineTimer will use the same clock as QElapsedTimer (see clockType() and isMonotonic() ).

Timer types¶

Like QTimer , QDeadlineTimer can select among different levels of coarseness on the timers. You can select precise timing by passing PreciseTimer to the functions that set of change the timer, or you can select coarse timing by passing CoarseTimer . VeryCoarseTimer is currently interpreted the same way as 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 PreciseTimer was passed.

QDeadlineTimer defaults to 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.

`` std::chrono``

Compatibility¶

QDeadlineTimer is compatible with the std::chrono API from C++11 and can be constructed from or compared to both std::chrono::duration and 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:

namespace = using()
namespace = using()
deadline = QDeadlineTimer(30s)
device.waitForReadyRead(deadline)
if (deadline.remainingTime<nanoseconds>() > 300ms)
    cleanup()

As can be seen in the example above, QDeadlineTimer offers a templated version of remainingTime() and deadline() that can be used to return std::chrono objects.

Note that comparing to time_point is not as efficient as comparing to duration, since QDeadlineTimer may need to convert from its own internal clock source to the clock source used by the 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:

namespace = using()
namespace = using()
now = steady_clock::now()
deadline = QDeadlineTimer(now + 1s)
Q_ASSERT(deadline == now + 1s)

See also

QTime QTimer QDeadlineTimer TimerType

class PySide6.QtCore.QDeadlineTimer(arg__1[, type_=Qt.CoarseTimer])¶

PySide6.QtCore.QDeadlineTimer([type_=Qt.CoarseTimer])

PySide6.QtCore.QDeadlineTimer(QDeadlineTimer)

PySide6.QtCore.QDeadlineTimer(msecs[, type=Qt.CoarseTimer])

Parameters

type – TimerType
QDeadlineTimer – PySide6.QtCore.QDeadlineTimer
msecs – int
type – TimerType
arg__1 – ForeverConstant

QDeadlineTimer objects created with ForeverConstant never expire. For such objects, remainingTime() will return -1, deadline() will return the maximum value, and isForever() will return true.

The timer type timerType may be ignored, since the timer will never expire.

See also

ForeverConstant hasExpired() isForever() remainingTime() timerType()

Constructs an expired QDeadlineTimer object. For this object, remainingTime() will return 0.

The timer type 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 current() .

See also

hasExpired() remainingTime() TimerType current()

Constructs a QDeadlineTimer object with an expiry time of msecs msecs from the moment of the creation of this object, if msecs is positive. If 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 msecs is -1, the timer will be set to never expire, causing remainingTime() to return -1 and deadline() to return the maximum value.

The QDeadlineTimer object will be constructed with the specified timer type.

For optimization purposes, if 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 current() and add time to it.

See also

hasExpired() isForever() remainingTime() setRemainingTime()

PySide6.QtCore.QDeadlineTimer.ForeverConstant¶

Constant	Description
QDeadlineTimer.Forever	Used when creating a `QDeadlineTimer` to indicate the deadline should not expire

PySide6.QtCore.QDeadlineTimer._q_data()¶

Return type

static PySide6.QtCore.QDeadlineTimer.addNSecs(dt, nsecs)¶

Parameters

dt – PySide6.QtCore.QDeadlineTimer
nsecs – int

Return type

PySide6.QtCore.QDeadlineTimer

Returns a QDeadlineTimer object whose deadline is extended from dt's deadline by nsecs nanoseconds. If dt was set to never expire, this function returns a QDeadlineTimer that will not expire either.

Note

if dt was created as expired, its deadline is indeterminate and adding an amount of time may or may not cause it to become unexpired.

static PySide6.QtCore.QDeadlineTimer.current([timerType=Qt.CoarseTimer])¶

Parameters: timerType – TimerType
Return type: PySide6.QtCore.QDeadlineTimer

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 the specified timerType.

PySide6.QtCore.QDeadlineTimer.deadline()¶

Return type: int

Returns the absolute time point for the deadline stored in QDeadlineTimer object, calculated in milliseconds relative to the reference clock, the same as msecsSinceReference() . The value will be in the past if this QDeadlineTimer has expired.

If this QDeadlineTimer never expires, this function returns std::numeric_limits<qint64>::max().

This function can be used to calculate the amount of time a timer is overdue, by subtracting current() or msecsSinceReference() , as in the following example:

realTimeLeft = deadline.deadline()
if (realTimeLeft != (std.numeric_limits<qint64>.max)()) {
    realTimeLeft -= QDeadlineTimer.current().deadline()
    # or:
    #QElapsedTimer timer
    #timer.start()
    #realTimeLeft -= timer.msecsSinceReference()

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.

Table of Contents

Previous topic

Next topic