1 /**************************************************************************** 2 ** 3 ** Copyright (C) 2016 Intel Corporation. 4 ** Contact: https://www.qt.io/licensing/ 5 ** 6 ** This file is part of the QtCore module of the Qt Toolkit. 7 ** 8 ** $QT_BEGIN_LICENSE:LGPL$ 9 ** Commercial License Usage 10 ** Licensees holding valid commercial Qt licenses may use this file in 11 ** accordance with the commercial license agreement provided with the 12 ** Software or, alternatively, in accordance with the terms contained in 13 ** a written agreement between you and The Qt Company. For licensing terms 14 ** and conditions see https://www.qt.io/terms-conditions. For further 15 ** information use the contact form at https://www.qt.io/contact-us. 16 ** 17 ** GNU Lesser General Public License Usage 18 ** Alternatively, this file may be used under the terms of the GNU Lesser 19 ** General Public License version 3 as published by the Free Software 20 ** Foundation and appearing in the file LICENSE.LGPL3 included in the 21 ** packaging of this file. Please review the following information to 22 ** ensure the GNU Lesser General Public License version 3 requirements 23 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. 24 ** 25 ** GNU General Public License Usage 26 ** Alternatively, this file may be used under the terms of the GNU 27 ** General Public License version 2.0 or (at your option) the GNU General 28 ** Public license version 3 or any later version approved by the KDE Free 29 ** Qt Foundation. The licenses are as published by the Free Software 30 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 31 ** included in the packaging of this file. Please review the following 32 ** information to ensure the GNU General Public License requirements will 33 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and 34 ** https://www.gnu.org/licenses/gpl-3.0.html. 35 ** 36 ** $QT_END_LICENSE$ 37 ** 38 ****************************************************************************/ 39 40 #ifndef QDEADLINETIMER_H 41 #define QDEADLINETIMER_H 42 43 #include <QtCore/qelapsedtimer.h> 44 #include <QtCore/qmetatype.h> 45 #include <QtCore/qnamespace.h> 46 #include <QtCore/qpair.h> 47 48 #ifdef max 49 // un-pollute the namespace. We need std::numeric_limits::max() and std::chrono::duration::max() 50 # undef max 51 #endif 52 53 #include <limits> 54 55 #if __has_include(<chrono>) 56 # include <chrono> 57 #endif 58 59 QT_BEGIN_NAMESPACE 60 61 class Q_CORE_EXPORT QDeadlineTimer 62 { 63 public: 64 enum ForeverConstant { Forever }; 65 66 Q_DECL_CONSTEXPR QDeadlineTimer(Qt::TimerType type_ = Qt::CoarseTimer) noexcept 67 : t1(0), t2(0), type(type_) {} 68 Q_DECL_CONSTEXPR QDeadlineTimer(ForeverConstant, Qt::TimerType type_ = Qt::CoarseTimer) noexcept t1(std::numeric_limits<qint64>::max ())69 : t1(std::numeric_limits<qint64>::max()), t2(0), type(type_) {} 70 explicit QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer) noexcept; 71 swap(QDeadlineTimer & other)72 void swap(QDeadlineTimer &other) noexcept 73 { qSwap(t1, other.t1); qSwap(t2, other.t2); qSwap(type, other.type); } 74 isForever()75 Q_DECL_CONSTEXPR bool isForever() const noexcept 76 { return t1 == (std::numeric_limits<qint64>::max)(); } 77 bool hasExpired() const noexcept; 78 timerType()79 Qt::TimerType timerType() const noexcept 80 { return Qt::TimerType(type & 0xff); } 81 void setTimerType(Qt::TimerType type); 82 83 qint64 remainingTime() const noexcept; 84 qint64 remainingTimeNSecs() const noexcept; 85 void setRemainingTime(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer) noexcept; 86 void setPreciseRemainingTime(qint64 secs, qint64 nsecs = 0, 87 Qt::TimerType type = Qt::CoarseTimer) noexcept; 88 89 qint64 deadline() const noexcept Q_DECL_PURE_FUNCTION; 90 qint64 deadlineNSecs() const noexcept Q_DECL_PURE_FUNCTION; 91 void setDeadline(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer) noexcept; 92 void setPreciseDeadline(qint64 secs, qint64 nsecs = 0, 93 Qt::TimerType type = Qt::CoarseTimer) noexcept; 94 95 static QDeadlineTimer addNSecs(QDeadlineTimer dt, qint64 nsecs) noexcept Q_DECL_PURE_FUNCTION; 96 static QDeadlineTimer current(Qt::TimerType timerType = Qt::CoarseTimer) noexcept; 97 98 friend bool operator==(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 99 { return d1.t1 == d2.t1 && d1.t2 == d2.t2; } 100 friend bool operator!=(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 101 { return !(d1 == d2); } 102 friend bool operator<(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 103 { return d1.t1 < d2.t1 || (d1.t1 == d2.t1 && d1.t2 < d2.t2); } 104 friend bool operator<=(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 105 { return d1 == d2 || d1 < d2; } 106 friend bool operator>(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 107 { return d2 < d1; } 108 friend bool operator>=(QDeadlineTimer d1, QDeadlineTimer d2) noexcept 109 { return !(d1 < d2); } 110 111 friend Q_CORE_EXPORT QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs); 112 friend QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt) 113 { return dt + msecs; } 114 friend QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs) 115 { return dt + (-msecs); } 116 friend qint64 operator-(QDeadlineTimer dt1, QDeadlineTimer dt2) 117 { return (dt1.deadlineNSecs() - dt2.deadlineNSecs()) / (1000 * 1000); } 118 QDeadlineTimer &operator+=(qint64 msecs) 119 { *this = *this + msecs; return *this; } 120 QDeadlineTimer &operator-=(qint64 msecs) 121 { *this = *this + (-msecs); return *this; } 122 123 #if __has_include(<chrono>) || defined(Q_CLANG_QDOC) 124 template <class Clock, class Duration> 125 QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline_, 126 Qt::TimerType type_ = Qt::CoarseTimer) : t2(0) 127 { setDeadline(deadline_, type_); } 128 template <class Clock, class Duration> 129 QDeadlineTimer &operator=(std::chrono::time_point<Clock, Duration> deadline_) 130 { setDeadline(deadline_); return *this; } 131 132 template <class Clock, class Duration> 133 void setDeadline(std::chrono::time_point<Clock, Duration> deadline_, 134 Qt::TimerType type_ = Qt::CoarseTimer) 135 { setRemainingTime(deadline_ == deadline_.max() ? Duration::max() : deadline_ - Clock::now(), type_); } 136 137 template <class Clock, class Duration = typename Clock::duration> deadline()138 std::chrono::time_point<Clock, Duration> deadline() const 139 { 140 auto val = std::chrono::nanoseconds(rawRemainingTimeNSecs()) + Clock::now(); 141 return std::chrono::time_point_cast<Duration>(val); 142 } 143 144 template <class Rep, class Period> 145 QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type_ = Qt::CoarseTimer) 146 : t2(0) 147 { setRemainingTime(remaining, type_); } 148 149 template <class Rep, class Period> 150 QDeadlineTimer &operator=(std::chrono::duration<Rep, Period> remaining) 151 { setRemainingTime(remaining); return *this; } 152 153 template <class Rep, class Period> 154 void setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type_ = Qt::CoarseTimer) 155 { 156 if (remaining == remaining.max()) 157 *this = QDeadlineTimer(Forever, type_); 158 else 159 setPreciseRemainingTime(0, std::chrono::nanoseconds(remaining).count(), type_); 160 } 161 remainingTimeAsDuration()162 std::chrono::nanoseconds remainingTimeAsDuration() const noexcept 163 { 164 if (isForever()) 165 return std::chrono::nanoseconds::max(); 166 qint64 nsecs = rawRemainingTimeNSecs(); 167 if (nsecs <= 0) 168 return std::chrono::nanoseconds::zero(); 169 return std::chrono::nanoseconds(nsecs); 170 } 171 172 template <class Rep, class Period> 173 friend QDeadlineTimer operator+(QDeadlineTimer dt, std::chrono::duration<Rep, Period> value) 174 { return QDeadlineTimer::addNSecs(dt, std::chrono::duration_cast<std::chrono::nanoseconds>(value).count()); } 175 template <class Rep, class Period> 176 friend QDeadlineTimer operator+(std::chrono::duration<Rep, Period> value, QDeadlineTimer dt) 177 { return dt + value; } 178 template <class Rep, class Period> 179 friend QDeadlineTimer operator+=(QDeadlineTimer &dt, std::chrono::duration<Rep, Period> value) 180 { return dt = dt + value; } 181 #endif 182 183 private: 184 qint64 t1; 185 unsigned t2; 186 unsigned type; 187 188 qint64 rawRemainingTimeNSecs() const noexcept; 189 190 public: 191 // This is not a public function, it's here only for Qt's internal convenience... _q_data()192 QPair<qint64, unsigned> _q_data() const { return qMakePair(t1, t2); } 193 }; 194 195 Q_DECLARE_SHARED(QDeadlineTimer) 196 197 QT_END_NAMESPACE 198 199 Q_DECLARE_METATYPE(QDeadlineTimer) 200 201 #endif // QDEADLINETIMER_H 202