QDeadlineTimer Class

Documentation des fonctions membres

Crée un objet ` QDeadlineTimer ` dont le délai d'expiration est écoulé. Pour cet objet, la méthode ` remainingTime()` renverra 0. Si ` timerType ` n'est pas défini, l'objet utilisera la valeur par défaut ` coarse ` timer type.

Le type de minuteur timerType peut être ignoré, car le minuteur a déjà expiré. De même, à des fins d’optimisation, cette fonction ne tentera pas d’obtenir l’heure actuelle et utilisera une valeur connue pour appartenir au passé. Par conséquent, la fonction deadline() peut renvoyer une valeur inattendue et cet objet ne peut pas être utilisé pour calculer depuis combien de temps il est en retard. Si cette fonctionnalité est requise, utilisez la fonction QDeadlineTimer::current().

Voir également hasExpired(), remainingTime(), Qt::TimerType et current().

[constexpr noexcept] QDeadlineTimer::QDeadlineTimer(QDeadlineTimer::ForeverConstant, Qt::TimerType timerType = Qt::CoarseTimer)

Les objets `QDeadlineTimer` créés avec ` ForeverConstant ` n'expirent jamais. Pour ces objets, la fonction ` remainingTime()` renvoie -1, ` deadline()` renvoie la valeur maximale et ` isForever()` renvoie `true`.

Le type de minuteur « timerType » peut être ignoré, puisque le minuteur n'expirera jamais.

Voir également ForeverConstant, hasExpired(), isForever(), remainingTime() et timerType().

[explicit noexcept] QDeadlineTimer::QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer)

Crée un objet `QDeadlineTimer` dont l'expiration est fixée à ` msecs ` millisecondes à compter du moment de la création de cet objet, si `msecs` est positif. Si ` msecs ` est égal à zéro, ce `QDeadlineTimer` sera marqué comme expiré, ce qui fera que ` remainingTime()` renverra zéro et que ` deadline()` renverra un moment indéterminé dans le passé. Si ` msecs ` est négatif, le minuteur sera configuré pour ne jamais expirer, ce qui fera que ` remainingTime()` renverra -1 et que ` deadline()` renverra la valeur maximale.

L'objet QDeadlineTimer sera instancié avec le minuteur spécifié type.

À des fins d’optimisation, si msecs est égal à zéro, cette fonction peut omettre de récupérer l’heure actuelle et utiliser à la place une valeur connue comme appartenant au passé. Dans ce cas, deadline() peut renvoyer une valeur inattendue et cet objet ne peut pas être utilisé pour calculer depuis combien de temps il est en retard. Si cette fonctionnalité est requise, utilisez QDeadlineTimer::current() et ajoutez-y du temps.

Voir également hasExpired(), isForever(), remainingTime() et setRemainingTime().

template <typename Rep, typename Period> QDeadlineTimer::QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)

Crée un objet `QDeadlineTimer` avec un temps restant de ` remaining`. Si ` remaining ` est égal à zéro ou à une valeur négative, cet objet `QDeadlineTimer` sera marqué comme expiré, tandis que si ` remaining ` est égal à ` duration::max()`, l'objet sera configuré pour ne jamais expirer.

L'objet QDeadlineTimer sera instancié avec le minuteur spécifié type.

Ce constructeur peut être utilisé avec les littéraux de temps définis par l'utilisateur de C++14, comme dans :

    using namespace std::chrono_literals;
    QDeadlineTimer deadline(250ms);

À des fins d’optimisation, si remaining est égal à zéro ou à une valeur négative, cette fonction peut omettre de récupérer l’heure actuelle et utiliser à la place une valeur connue comme appartenant au passé. Si cela se produit, la fonction deadline() peut renvoyer une valeur inattendue et cet objet ne pourra pas être utilisé pour calculer depuis combien de temps il est en retard. Si cette fonctionnalité est requise, utilisez la fonction QDeadlineTimer::current() et ajoutez-y du temps.

Voir également hasExpired(), isForever(), remainingTime() et setRemainingTime().

template <typename Clock, typename Duration = typename Clock::duration> QDeadlineTimer::QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)

Crée un objet QDeadlineTimer avec une échéance fixée à l'instant deadline, en convertissant la source d'horloge Clock vers la source d'horloge interne de Qt (voir QElapsedTimer::clockType()).

Si deadline se situe dans le passé, cet objet QDeadlineTimer est marqué comme expiré, tandis que si deadline est égal à Duration::max(), cet objet est alors marqué comme n'expirant jamais.

L'objet QDeadlineTimer sera instancié avec le délai spécifié type.

Voir également hasExpired(), isForever(), remainingTime() et setDeadline().

[static noexcept] QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs)

Renvoie un objet ` QDeadlineTimer ` dont la date d'expiration est prolongée de ` nsecs ` nanosecondes par rapport à celle de ` dt`. Si ` dt ` a été défini pour ne jamais expirer, cette fonction renvoie un objet ` QDeadlineTimer ` qui n'expirera pas non plus.

[static noexcept] QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType = Qt::CoarseTimer)

Renvoie un objet ` QDeadlineTimer ` dont la durée de validité a expiré, mais qui contient obligatoirement l'heure actuelle. Les objets créés par cette fonction peuvent être utilisés pour calculer depuis combien de temps un minuteur est en retard, à l'aide de la fonction ` deadline()`.

L'objet ` QDeadlineTimer ` sera construit avec le ` timerType` spécifié.

[noexcept] qint64 QDeadlineTimer::deadline() const

Renvoie l'instant absolu correspondant à la date limite stockée dans l'objet ` QDeadlineTimer `, calculé en millisecondes par rapport à l'horloge de référence, de la même manière que la fonction ` QElapsedTimer::msecsSinceReference()`. La valeur sera antérieure à la date actuelle si cet objet ` QDeadlineTimer ` a expiré.

Si cet QDeadlineTimer n’expire jamais, cette fonction renvoie std::numeric_limits<qint64>::max().

Cette fonction peut être utilisée pour calculer le temps de retard d’un minuteur, en soustrayant QDeadlineTimer::current() ou QElapsedTimer::msecsSinceReference(), comme dans l’exemple suivant :

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

Voir également remainingTime(), deadlineNSecs() et setDeadline().

[noexcept] qint64 QDeadlineTimer::deadlineNSecs() const

Renvoie l'instant absolu correspondant à la date limite stockée dans l'objet ` QDeadlineTimer `, calculé en nanosecondes par rapport à l'horloge de référence, de la même manière que la fonction ` QElapsedTimer::msecsSinceReference()`. La valeur sera antérieure à la date actuelle si cette ` QDeadlineTimer ` a expiré.

Si cet QDeadlineTimer n'expire jamais ou si le nombre de nanosecondes restant avant l'échéance ne peut pas être représenté par le type de retour, cette fonction renvoie std::numeric_limits<qint64>::max().

Cette fonction peut être utilisée pour calculer le temps de retard d’un minuteur, en soustrayant QDeadlineTimer::current(), comme dans l’exemple suivant :

    qint64 realTimeLeft = deadline.deadlineNSecs();
    if (realTimeLeft != std::numeric_limits<qint64>::max())
        realTimeLeft -= QDeadlineTimer::current().deadlineNSecs();

Voir également remainingTime(), deadline() et setDeadline().

[noexcept] bool QDeadlineTimer::hasExpired() const

Renvoie « true » si cet objet « QDeadlineTimer » a expiré, et « false » s'il reste du temps. Pour les objets qui ont expiré, la fonction « remainingTime() » renverra zéro et la fonction « deadline() » renverra un moment dans le passé.

QDeadlineTimer Les objets créés avec la méthode ForeverConstant n’expirent jamais et cette fonction renvoie toujours « false » pour ceux-ci.

Voir également isForever() et remainingTime().

[constexpr noexcept] bool QDeadlineTimer::isForever() const

Renvoie « true » si cet objet QDeadlineTimer n’expire jamais, « false » dans le cas contraire. Pour les minuteurs qui n’expirent jamais, la fonction remainingTime() renvoie toujours -1 et la fonction deadline() renvoie la valeur maximale.

Voir également ForeverConstant, hasExpired() et remainingTime().

[noexcept] qint64 QDeadlineTimer::remainingTime() const

Renvoie le temps restant dans cet objet ` QDeadlineTimer ` en millisecondes. Si le minuteur a déjà expiré, cette fonction renvoie zéro ; il n’est pas possible d’obtenir la durée écoulée à l’aide de cette fonction (pour cela, voir ` deadline()`). Si le minuteur a été configuré pour ne jamais expirer, cette fonction renvoie -1.

Cette fonction est adaptée à une utilisation dans les API Qt qui utilisent un délai d’expiration en millisecondes, comme les nombreuses fonctions QIODevice waitFor ou les fonctions de verrouillage temporisé disponibles dans QMutex, QWaitCondition, QSemaphore ou QReadWriteLock. Par exemple :

    mutex.tryLock(deadline.remainingTime());

Voir également setRemainingTime(), remainingTimeNSecs(), isForever() et hasExpired().

[noexcept] std::chrono::nanoseconds QDeadlineTimer::remainingTimeAsDuration() const

Renvoie le temps restant avant la date limite.

[noexcept] qint64 QDeadlineTimer::remainingTimeNSecs() const

Renvoie le temps restant dans cet objet ` QDeadlineTimer ` en nanosecondes. Si le minuteur a déjà expiré, cette fonction renvoie zéro ; il n'est pas possible d'obtenir la durée écoulée à l'aide de cette fonction. Si le minuteur a été configuré pour ne jamais expirer, cette fonction renvoie -1.

Voir également remainingTime(), isForever() et hasExpired().

[noexcept] void QDeadlineTimer::setDeadline(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)

Définit la date limite de cet objet ` QDeadlineTimer ` sur l'instant absolu ` msecs `, exprimé en millisecondes à partir de l'horloge de référence (identique à ` QElapsedTimer::msecsSinceReference()`), et le type de minuteur sur ` timerType`. Si la valeur correspond à un moment passé, cet objet ` QDeadlineTimer ` sera marqué comme expiré.

Si msecs est std::numeric_limits<qint64>::max() ou si la date limite se situe au-delà d’un moment représentable dans le futur, cette QDeadlineTimer sera définie comme n’expirant jamais.

Voir également setPreciseDeadline(), deadline(), deadlineNSecs() et setRemainingTime().

template <typename Clock, typename Duration = typename Clock::duration> void QDeadlineTimer::setDeadline(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)

Définit cet objet ` QDeadlineTimer ` sur la date limite indiquée par le point temporel ` deadline `, en effectuant la conversion entre la source d'horloge ` Clock ` et la source d'horloge interne de Qt (voir QElapsedTimer::clockType()).

Si deadline se situe dans le passé, cet objet QDeadlineTimer est défini comme expiré, tandis que si deadline est égal à Duration::max(), cet objet est alors défini comme n'expirant jamais.

Le type de temporisateur de cet objet « QDeadlineTimer » sera défini sur la valeur spécifiée « type ».

Voir également hasExpired(), isForever() et remainingTime().

[noexcept] void QDeadlineTimer::setPreciseDeadline(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)

Définit la date limite de cet objet ` QDeadlineTimer ` à ` secs ` secondes et ` nsecs ` nanosecondes depuis l'époque de l'horloge de référence (identique à ` QElapsedTimer::msecsSinceReference()`), et le type de minuteur à ` timerType`. Si la valeur est antérieure à la date actuelle, cet objet ` QDeadlineTimer ` sera marqué comme expiré.

Si secs ou nsecs est égal à std::numeric_limits<qint64>::max(), ce QDeadlineTimer sera défini pour ne jamais expirer. Si nsecs est supérieur à 1 milliard de nanosecondes (1 seconde), alors secs sera ajusté en conséquence.

Voir également setDeadline(), deadline(), deadlineNSecs() et setRemainingTime().

[noexcept] void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)

Définit la durée restante de cet objet QDeadlineTimer à secs secondes plus nsecs nanosecondes à compter de maintenant, si secs a une valeur positive. Si secs est négatif, cet objet QDeadlineTimer sera configuré pour ne jamais expirer (ce comportement ne s'applique pas à nsecs). Si les deux paramètres sont égaux à zéro, cet objet QDeadlineTimer sera marqué comme expiré.

À des fins d’optimisation, si secs et nsecs sont tous deux égaux à zéro, cette fonction peut ne pas récupérer l’heure actuelle et utiliser à la place une valeur connue comme appartenant au passé. Dans ce cas, deadline() peut renvoyer une valeur inattendue et cet objet ne peut pas être utilisé pour calculer depuis combien de temps il est périmé. Si cette fonctionnalité est requise, utilisez QDeadlineTimer::current() et ajoutez-y du temps.

Le type de minuteur de cet objet ` QDeadlineTimer ` sera défini sur la valeur spécifiée ` timerType`.

Voir également setRemainingTime(), hasExpired(), isForever() et remainingTime().

[noexcept] void QDeadlineTimer::setRemainingTime(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)

Définit la durée restante de cet objet ` QDeadlineTimer ` à ` msecs ` millisecondes à compter de maintenant, si ` msecs ` a une valeur positive. Si ` msecs ` est égal à zéro, cet objet ` QDeadlineTimer ` sera marqué comme expiré, tandis qu’une valeur négative le configurera pour qu’il n’expire jamais.

À des fins d’optimisation, si msecs est égal à zéro, cette fonction peut ne pas récupérer l’heure actuelle et utiliser à la place une valeur connue comme appartenant au passé. Si cela se produit, deadline() peut renvoyer une valeur inattendue et cet objet ne pourra pas être utilisé pour calculer depuis combien de temps il est périmé. Si cette fonctionnalité est requise, utilisez QDeadlineTimer::current() et ajoutez-y du temps.

Le type de minuteur de cet objet ` QDeadlineTimer ` sera défini sur la valeur spécifiée par ` timerType`.

Voir également setPreciseRemainingTime(), hasExpired(), isForever() et remainingTime().

template <typename Rep, typename Period> void QDeadlineTimer::setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)

Définit la durée restante de cet objet « QDeadlineTimer » sur remaining. Si remaining est égal à zéro ou à une valeur négative, cet objet « QDeadlineTimer » sera marqué comme expiré, tandis que si remaining est égal à duration::max(), l'objet sera configuré pour ne jamais expirer.

Le type de temporisateur de cet objet QDeadlineTimer sera défini sur le type spécifié.

Cette fonction peut être utilisée avec les littéraux définis par l'utilisateur de C++14 pour le temps, comme dans :

    using namespace std::chrono_literals;
    deadline.setRemainingTime(250ms);

Voir également setDeadline(), remainingTime(), hasExpired() et isForever().

void QDeadlineTimer::setTimerType(Qt::TimerType timerType)

Modifie le type de minuterie de cet objet pour le remplacer par « timerType ».

Le comportement associé à chaque valeur possible de ` timerType ` dépend du système d'exploitation. ` Qt::PreciseTimer ` utilise le minuteur le plus précis que Qt peut trouver, avec une résolution de 1 milliseconde ou mieux, tandis que ` QDeadlineTimer ` tente d'utiliser un minuteur moins précis pour ` Qt::CoarseTimer ` et ` Qt::VeryCoarseTimer`.

Voir également timerType() et Qt::TimerType.

[noexcept] void QDeadlineTimer::swap(QDeadlineTimer &other)

Remplace ce compte à rebours par other. Cette opération est très rapide et ne pose jamais de problème.

[noexcept] Qt::TimerType QDeadlineTimer::timerType() const

Renvoie le type de minuterie actif pour cet objet.

Voir aussi setTimerType().

QDeadlineTimer &QDeadlineTimer::operator+=(qint64 msecs)

Prolonge cet objet ` QDeadlineTimer ` de ` msecs ` millisecondes et renvoie l'objet lui-même. Si cet objet est configuré pour ne jamais expirer, cette fonction ne fait rien.

Pour ajouter des durées d'une précision supérieure à 1 milliseconde, utilisez ` addNSecs()`.

QDeadlineTimer &QDeadlineTimer::operator-=(qint64 msecs)

Réduit la durée de vie de cet objet ` QDeadlineTimer ` de ` msecs ` millisecondes et renvoie l'objet lui-même. Si cet objet est configuré pour ne jamais expirer, cette fonction ne fait rien.

Pour soustraire des durées dont la précision est supérieure à 1 milliseconde, utilisez ` addNSecs()`.

template <typename Rep, typename Period> QDeadlineTimer &QDeadlineTimer::operator=(std::chrono::duration<Rep, Period> remaining)

Règle ce minuteur de délai sur l'heure indiquée dans le fichier « remaining ».

template <typename Clock, typename Duration = typename Clock::duration> QDeadlineTimer &QDeadlineTimer::operator=(std::chrono::time_point<Clock, Duration> deadline_)

Associe « deadline_ » à ce compte à rebours.