Line data Source code
1 : /* 2 : MIT License 3 : Copyright (c) 2017 André L. Maravilha 4 : Permission is hereby granted, free of charge, to any person obtaining a copy 5 : of this software and associated documentation files (the "Software"), to deal 6 : in the Software without restriction, including without limitation the rights 7 : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 : copies of the Software, and to permit persons to whom the Software is 9 : furnished to do so, subject to the following conditions: 10 : The above copyright notice and this permission notice shall be included in all 11 : copies or substantial portions of the Software. 12 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 13 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 14 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 15 : AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 16 : LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 17 : OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 18 : SOFTWARE. 19 : */ 20 : 21 : /* 22 : * https://github.com/andremaravilha/cxxtimer 23 : * commit: a48bd81d9168a4e258123a84fc150912dd65ce79 24 : */ 25 : 26 : #ifndef CXX_TIMER_HPP 27 : #define CXX_TIMER_HPP 28 : 29 : #include <chrono> 30 : 31 : 32 : namespace cxxtimer { 33 : 34 : /** 35 : * This class works as a stopwatch. 36 : */ 37 : class Timer { 38 : 39 : public: 40 : 41 : /** 42 : * Constructor. 43 : * 44 : * @param start 45 : * If true, the timer is started just after construction. 46 : * Otherwise, it will not be automatically started. 47 : */ 48 : explicit Timer(bool start = false); 49 : 50 : /** 51 : * Copy constructor. 52 : * 53 : * @param other 54 : * The object to be copied. 55 : */ 56 56 : Timer(const Timer& other) = default; 57 : 58 : /** 59 : * Transfer constructor. 60 : * 61 : * @param other 62 : * The object to be transferred. 63 : */ 64 112 : Timer(Timer&& other) = default; 65 : 66 : /** 67 : * Destructor. 68 : */ 69 4326 : virtual ~Timer() = default; 70 : 71 : /** 72 : * Assignment operator by copy. 73 : * 74 : * @param other 75 : * The object to be copied. 76 : * 77 : * @return A reference to this object. 78 : */ 79 : Timer& operator=(const Timer& other) = default; 80 : 81 : /** 82 : * Assignment operator by transfer. 83 : * 84 : * @param other 85 : * The object to be transferred. 86 : * 87 : * @return A reference to this object. 88 : */ 89 : Timer& operator=(Timer&& other) = default; 90 : 91 : /** 92 : * Start/resume the timer. 93 : */ 94 : void start(); 95 : 96 : /** 97 : * Stop/pause the timer. 98 : */ 99 : void stop(); 100 : 101 : /** 102 : * Reset the timer. 103 : */ 104 : void reset(); 105 : 106 : /** 107 : * Return the elapsed time. 108 : * 109 : * @param duration_t 110 : * The duration type used to return the time elapsed. If not 111 : * specified, it returns the time as represented by 112 : * std::chrono::milliseconds. 113 : * 114 : * @return The elapsed time. 115 : */ 116 : template <class duration_t = std::chrono::milliseconds> 117 : typename duration_t::rep count() const; 118 : 119 : private: 120 : 121 : bool started_; 122 : bool paused_; 123 : std::chrono::steady_clock::time_point reference_; 124 : std::chrono::duration<long double> accumulated_; 125 : }; 126 : 127 : } 128 : 129 : 130 4937 : inline cxxtimer::Timer::Timer(bool start) : 131 : started_(false), paused_(false), 132 4937 : reference_(std::chrono::steady_clock::now()), 133 4881 : accumulated_(std::chrono::duration<long double>(0)) { 134 4937 : if (start) { 135 4937 : this->start(); 136 : } 137 : } 138 : 139 4937 : inline void cxxtimer::Timer::start() { 140 4937 : if (!started_) { 141 4937 : started_ = true; 142 4937 : paused_ = false; 143 4937 : accumulated_ = std::chrono::duration<long double>(0); 144 4937 : reference_ = std::chrono::steady_clock::now(); 145 0 : } else if (paused_) { 146 0 : reference_ = std::chrono::steady_clock::now(); 147 0 : paused_ = false; 148 : } 149 4937 : } 150 : 151 2757 : inline void cxxtimer::Timer::stop() { 152 2757 : if (started_ && !paused_) { 153 2757 : std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now(); 154 2757 : accumulated_ = accumulated_ + std::chrono::duration_cast< std::chrono::duration<long double> >(now - reference_); 155 2757 : paused_ = true; 156 : } 157 2757 : } 158 : 159 : inline void cxxtimer::Timer::reset() { 160 : if (started_) { 161 : started_ = false; 162 : paused_ = false; 163 : reference_ = std::chrono::steady_clock::now(); 164 : accumulated_ = std::chrono::duration<long double>(0); 165 : } 166 : } 167 : 168 : template <class duration_t> 169 4846 : typename duration_t::rep cxxtimer::Timer::count() const { 170 4846 : if (started_) { 171 4846 : if (paused_) { 172 2700 : return std::chrono::duration_cast<duration_t>(accumulated_).count(); 173 : } else { 174 2146 : return std::chrono::duration_cast<duration_t>( 175 2146 : accumulated_ + (std::chrono::steady_clock::now() - reference_)).count(); 176 : } 177 : } else { 178 : return duration_t(0).count(); 179 : } 180 : } 181 : 182 : 183 : #endif