qelapsedtimer.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qelapsedtimer.h"
 
QT_BEGIN_NAMESPACE
 
QElapsedTimer::ClockType QElapsedTimer::clockType() noexcept
{
    // we use std::chrono::steady_clock
    return MonotonicClock;
}
 
bool QElapsedTimer::isMonotonic() noexcept
{
    // We trust std::chrono::steady_clock to be steady (monotonic); if the
    // Standard Library is lying to us, users must complain to their vendor.
    return true;
}
 
void QElapsedTimer::start() noexcept
{
    static_assert(sizeof(t1) == sizeof(Duration::rep));
 
    // This assignment will work so long as TimePoint uses the same time
    // duration or one of finer granularity than steady_clock::time_point. That
    // means it will work until the first steady_clock using picoseconds.
    TimePoint now = std::chrono::steady_clock::now();
    t1 = now.time_since_epoch().count();
    QT6_ONLY(t2 = 0);
}
 
qint64 QElapsedTimer::restart() noexcept
{
    QElapsedTimer old = *this;
    start();
    return old.msecsTo(*this);
}
 
auto QElapsedTimer::durationElapsed() const noexcept -> Duration
{
    TimePoint then{Duration(t1)};
    return std::chrono::steady_clock::now() - then;
}
 
qint64 QElapsedTimer::nsecsElapsed() const noexcept
{
    return durationElapsed().count();
}
 
qint64 QElapsedTimer::elapsed() const noexcept
{
    using namespace std::chrono;
    return duration_cast<milliseconds>(durationElapsed()).count();
}
 
qint64 QElapsedTimer::msecsSinceReference() const noexcept
{
    using namespace std::chrono;
    return duration_cast<milliseconds>(Duration(t1)).count();
}
 
auto QElapsedTimer::durationTo(const QElapsedTimer &other) const noexcept -> Duration
{
    Duration d1(t1);
    Duration d2(other.t1);
    return d2 - d1;
}
 
qint64 QElapsedTimer::msecsTo(const QElapsedTimer &other) const noexcept
{
    using namespace std::chrono;
    return duration_cast<milliseconds>(durationTo(other)).count();
}
 
qint64 QElapsedTimer::secsTo(const QElapsedTimer &other) const noexcept
{
    using namespace std::chrono;
    return duration_cast<seconds>(durationTo(other)).count();
}
 
static const qint64 invalidData = Q_INT64_C(0x8000000000000000);
 
void QElapsedTimer::invalidate() noexcept
{
    t1 = t2 = invalidData;
}
 
bool QElapsedTimer::isValid() const noexcept
{
    return t1 != invalidData && t2 != invalidData;
}
 
bool QElapsedTimer::hasExpired(qint64 timeout) const noexcept
{
    // if timeout is -1, quint64(timeout) is LLINT_MAX, so this will be
    // considered as never expired
    return quint64(elapsed()) > quint64(timeout);
}
 
bool operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept
{
    return lhs.t1 < rhs.t1;
}
 
QT_END_NAMESPACE