110 lines
3.1 KiB
C++
110 lines
3.1 KiB
C++
#pragma once
|
|
|
|
#include "StarThread.hpp"
|
|
|
|
namespace Star {
|
|
|
|
STAR_CLASS(Clock);
|
|
STAR_CLASS(Timer);
|
|
|
|
namespace Time {
|
|
double timeSinceEpoch();
|
|
int64_t millisecondsSinceEpoch();
|
|
|
|
double monotonicTime();
|
|
int64_t monotonicMilliseconds();
|
|
int64_t monotonicMicroseconds();
|
|
|
|
// Pretty print a duration of time (In days, hours, minutes, seconds, and milliseconds)
|
|
String printDuration(double time);
|
|
|
|
// Pretty print a given date and time
|
|
String printDateAndTime(int64_t epochTicks, String format = "<year>-<month>-<day> <hours>:<minutes>:<seconds>.<millis>");
|
|
String printCurrentDateAndTime(String format = "<year>-<month>-<day> <hours>:<minutes>:<seconds>.<millis>");
|
|
|
|
// Ticks since unix epoch
|
|
int64_t epochTicks();
|
|
// Epoch ticks per second, static throughout application lifetime.
|
|
int64_t epochTickFrequency();
|
|
|
|
// Ticks since unspecified time before program start
|
|
int64_t monotonicTicks();
|
|
// Monotonic ticks per second, static throughout application lifetime.
|
|
int64_t monotonicTickFrequency();
|
|
|
|
double ticksToSeconds(int64_t ticks, int64_t tickFrequency);
|
|
int64_t ticksToMilliseconds(int64_t ticks, int64_t tickFrequency);
|
|
int64_t ticksToMicroseconds(int64_t ticks, int64_t tickFrequency);
|
|
int64_t secondsToTicks(double seconds, int64_t tickFrequency);
|
|
int64_t millisecondsToTicks(int64_t milliseconds, int64_t tickFrequency);
|
|
int64_t microsecondsToTicks(int64_t microseconds, int64_t tickFrequency);
|
|
}
|
|
|
|
// Keeps track of elapsed real time since a given moment. Guaranteed
|
|
// monotonically increasing and thread safe.
|
|
class Clock {
|
|
public:
|
|
explicit Clock(bool start = true);
|
|
|
|
Clock(Clock const& clock);
|
|
|
|
Clock& operator=(Clock const& clock);
|
|
|
|
// Resets clock to 0 time
|
|
void reset();
|
|
|
|
void stop();
|
|
void start();
|
|
|
|
bool running() const;
|
|
|
|
double time() const;
|
|
int64_t milliseconds() const;
|
|
|
|
// Override actual elapsed time with the given time.
|
|
void setTime(double time);
|
|
void setMilliseconds(int64_t millis);
|
|
|
|
// Warp the clock backwards or forwards
|
|
void adjustTime(double timeAdjustment);
|
|
void adjustMilliseconds(int64_t millisAdjustment);
|
|
|
|
private:
|
|
void updateElapsed() const;
|
|
|
|
mutable RecursiveMutex m_mutex;
|
|
mutable int64_t m_elapsedTicks;
|
|
mutable Maybe<int64_t> m_lastTicks;
|
|
bool m_running;
|
|
};
|
|
|
|
// An instance of Clock that counts down a given amount of time
|
|
class Timer : private Clock {
|
|
public:
|
|
static Timer withTime(double timeLeft, bool start = true);
|
|
static Timer withMilliseconds(int64_t millis, bool start = true);
|
|
|
|
// Constructs a stopped timer whose time is up.
|
|
Timer();
|
|
Timer(Timer const& timer);
|
|
Timer& operator=(Timer const& timer);
|
|
|
|
// Start the timer with the given time left.
|
|
void restart(double timeLeft);
|
|
void restartWithMilliseconds(int64_t millisecondsLeft);
|
|
|
|
// Time remaining on the timer. If negative is true, will return negative
|
|
// time values after the timer is up, if false it stops at zero.
|
|
double timeLeft(bool negative = false) const;
|
|
int64_t millisecondsLeft(bool negative = false) const;
|
|
|
|
// Is the time remaining <= 0.0?
|
|
bool timeUp() const;
|
|
|
|
using Clock::stop;
|
|
using Clock::start;
|
|
using Clock::running;
|
|
};
|
|
|
|
}
|