timestamp.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <chrono>
#include <cstdint>
#include <thread>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/duration.h>
#include <promeki/datatype.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class TimeStamp {
        public:
                PROMEKI_DATATYPE(TimeStamp, DataTypeTimeStamp, 1)
 
                
                static constexpr int64_t Invalid = INT64_MIN;
 
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<TimeStamp> readFromStream(DataStream &s);
 
                using Clock = std::chrono::steady_clock;
                using Value = std::chrono::time_point<Clock>;
                using Duration = Clock::duration;
 
                static Duration secondsToDuration(double val) {
                        std::chrono::duration<double> doubleDuration(val);
                        return std::chrono::duration_cast<Duration>(doubleDuration);
                }
 
                static void sleep(const Duration &d) {
                        std::this_thread::sleep_for(d);
                        return;
                }
 
                static TimeStamp now() {
                        return TimeStamp(
                                std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now().time_since_epoch())
                                        .count());
                }
 
                TimeStamp() = default;
 
                explicit TimeStamp(int64_t ns) : _ns(ns) {}
 
                TimeStamp(const Value &v)
                    : _ns(std::chrono::duration_cast<std::chrono::nanoseconds>(v.time_since_epoch()).count()) {}
 
                bool isValid() const { return _ns != Invalid; }
 
                operator Value() const { return Value(std::chrono::nanoseconds(_ns)); }
 
                TimeStamp &operator+=(const Duration &duration) {
                        if (isValid()) {
                                _ns += std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
                        }
                        return *this;
                }
 
                TimeStamp &operator-=(const Duration &duration) {
                        if (isValid()) {
                                _ns -= std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
                        }
                        return *this;
                }
 
                void setValue(const Value &v) {
                        _ns = std::chrono::duration_cast<std::chrono::nanoseconds>(v.time_since_epoch()).count();
                        return;
                }
 
                Value value() const { return Value(std::chrono::nanoseconds(_ns)); }
 
                void invalidate() { _ns = Invalid; }
 
                void update() {
                        _ns = std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now().time_since_epoch())
                                      .count();
                }
 
                void sleepUntil() const {
                        if (isValid()) std::this_thread::sleep_until(value());
                }
 
                Duration timeSinceEpoch() const {
                        return std::chrono::duration_cast<Duration>(std::chrono::nanoseconds(_ns));
                }
 
                double seconds() const {
                        if (!isValid()) return 0.0;
                        return static_cast<double>(_ns) / 1'000'000'000.0;
                }
 
                int64_t milliseconds() const {
                        if (!isValid()) return 0;
                        return _ns / 1'000'000LL;
                }
 
                int64_t microseconds() const {
                        if (!isValid()) return 0;
                        return _ns / 1'000LL;
                }
 
                int64_t nanoseconds() const { return _ns; }
 
                double elapsedSeconds() const {
                        if (!isValid()) return 0.0;
                        return std::chrono::duration_cast<std::chrono::duration<double>>(Clock::now() - value()).count();
                }
 
                int64_t elapsedMilliseconds() const {
                        if (!isValid()) return 0;
                        return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - value()).count();
                }
 
                int64_t elapsedMicroseconds() const {
                        if (!isValid()) return 0;
                        return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - value()).count();
                }
 
                int64_t elapsedNanoseconds() const {
                        if (!isValid()) return 0;
                        return std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - value()).count();
                }
 
                String toString() const {
                        if (!isValid()) return String("invalid");
                        return String::number(seconds());
                }
 
                static Result<TimeStamp> fromString(const String &s) {
                        if (s == "invalid") return makeResult(TimeStamp());
                        Error  e;
                        double v = s.to<double>(&e);
                        if (e.isError()) return makeError<TimeStamp>(Error::ParseFailed);
                        return makeResult(TimeStamp(Value(secondsToDuration(v))));
                }
 
                bool operator==(const TimeStamp &other) const { return _ns == other._ns; }
 
                bool operator!=(const TimeStamp &other) const { return _ns != other._ns; }
 
                bool operator<(const TimeStamp &other) const { return _ns < other._ns; }
                bool operator>(const TimeStamp &other) const { return _ns > other._ns; }
                bool operator<=(const TimeStamp &other) const { return _ns <= other._ns; }
                bool operator>=(const TimeStamp &other) const { return _ns >= other._ns; }
 
                operator String() const { return toString(); }
 
        private:
                int64_t _ns = Invalid;
};
 
inline TimeStamp operator+(const TimeStamp &ts, const TimeStamp::Duration &duration) {
        TimeStamp result(ts);
        result += duration;
        return result;
}
 
inline TimeStamp operator-(const TimeStamp &ts, const TimeStamp::Duration &duration) {
        TimeStamp result(ts);
        result -= duration;
        return result;
}
 
// ---------------------------------------------------------------------------
// promeki::Duration interop
//
// promeki::Duration and TimeStamp::Duration are intentionally different
// types — promeki::Duration is the library's portable nanosecond-precision
// value object, while TimeStamp::Duration is the platform's
// std::chrono::steady_clock::duration.  These free function overloads let
// callers do TimeStamp + promeki::Duration arithmetic directly, without
// the lossy round-trip through @c secondsToDuration / @c toSecondsDouble
// that earlier code had to fall back on.
//
// Implemented as free functions so the parameter type can be the
// namespace-level @c promeki::Duration without colliding with the
// in-class @c TimeStamp::Duration typedef.
// ---------------------------------------------------------------------------
 
inline TimeStamp::Duration toClockDuration(const Duration &d) {
        return std::chrono::duration_cast<TimeStamp::Duration>(std::chrono::nanoseconds(d.nanoseconds()));
}
 
inline TimeStamp &operator+=(TimeStamp &ts, const Duration &d) {
        if (!ts.isValid() || !d.isValid()) {
                ts.invalidate();
        } else {
                ts = TimeStamp(ts.nanoseconds() + d.nanoseconds());
        }
        return ts;
}
 
inline TimeStamp &operator-=(TimeStamp &ts, const Duration &d) {
        if (!ts.isValid() || !d.isValid()) {
                ts.invalidate();
        } else {
                ts = TimeStamp(ts.nanoseconds() - d.nanoseconds());
        }
        return ts;
}
 
inline TimeStamp operator+(const TimeStamp &ts, const Duration &d) {
        TimeStamp result(ts);
        result += d;
        return result;
}
 
inline TimeStamp operator-(const TimeStamp &ts, const Duration &d) {
        TimeStamp result(ts);
        result -= d;
        return result;
}
 
inline Duration operator-(const TimeStamp &a, const TimeStamp &b) {
        if (!a.isValid() || !b.isValid()) return Duration();
        return Duration::fromNanoseconds(a.nanoseconds() - b.nanoseconds());
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::TimeStamp);
 
#endif // PROMEKI_ENABLE_CORE