timestamp.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_TIME_TIMESTAMP_H
#define CPPCOMMON_TIME_TIMESTAMP_H
 
#include "time/timespan.h"
 
namespace CppCommon {
 
 
class Timestamp
{
public:
    Timestamp() noexcept : _timestamp(epoch()) {}
 
    explicit Timestamp(uint64_t timestamp) noexcept : _timestamp(timestamp) {}
 
    template <class Clock, class Duration>
    explicit Timestamp(const std::chrono::time_point<Clock, Duration>& time_point) noexcept : _timestamp(std::chrono::duration_cast<std::chrono::nanoseconds>(time_point.time_since_epoch()).count()) {}
    Timestamp(const Timestamp&) noexcept = default;
    Timestamp(Timestamp&&) noexcept = default;
    ~Timestamp() noexcept = default;
 
    Timestamp& operator=(uint64_t timestamp) noexcept
    { _timestamp = timestamp; return *this; }
    Timestamp& operator=(const Timestamp&) noexcept = default;
    Timestamp& operator=(Timestamp&&) noexcept = default;
 
    // Timestamp offset operations
    Timestamp& operator+=(int64_t offset) noexcept
    { _timestamp += offset; return *this; }
    Timestamp& operator+=(const Timespan& offset) noexcept
    { _timestamp += offset.total(); return *this; }
 
    Timestamp& operator-=(int64_t offset) noexcept
    { _timestamp -= offset; return *this; }
    Timestamp& operator-=(const Timespan& offset) noexcept
    { _timestamp -= offset.total(); return *this; }
 
    friend Timestamp operator+(const Timestamp& timestamp, int64_t offset) noexcept
    { return Timestamp(timestamp.total() + offset); }
    friend Timestamp operator+(int64_t offset, const Timestamp& timestamp) noexcept
    { return Timestamp(offset + timestamp.total()); }
    friend Timestamp operator+(const Timestamp& timestamp, const Timespan& offset) noexcept
    { return Timestamp(timestamp.total() + offset.total()); }
    friend Timestamp operator+(const Timespan& offset, const Timestamp& timestamp) noexcept
    { return Timestamp(offset.total() + timestamp.total()); }
 
    friend Timestamp operator-(const Timestamp& timestamp, int64_t offset) noexcept
    { return Timestamp(timestamp.total() - offset); }
    friend Timestamp operator-(int64_t offset, const Timestamp& timestamp) noexcept
    { return Timestamp(offset - timestamp.total()); }
    friend Timestamp operator-(const Timestamp& timestamp, const Timespan& offset) noexcept
    { return Timestamp(timestamp.total() - offset.total()); }
    friend Timestamp operator-(const Timespan& offset, const Timestamp& timestamp) noexcept
    { return Timestamp(offset.total() - timestamp.total()); }
 
    friend Timespan operator-(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return Timespan(timestamp1.total() - timestamp2.total()); }
 
    // Timestamp comparison
    friend bool operator==(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() == timestamp2; }
    friend bool operator==(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 == timestamp2.total(); }
    friend bool operator==(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() == timestamp2.total(); }
 
    friend bool operator!=(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() != timestamp2; }
    friend bool operator!=(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 != timestamp2.total(); }
    friend bool operator!=(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() != timestamp2.total(); }
 
    friend bool operator>(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() > timestamp2; }
    friend bool operator>(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 > timestamp2.total(); }
    friend bool operator>(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() > timestamp2.total(); }
 
    friend bool operator<(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() < timestamp2; }
    friend bool operator<(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 < timestamp2.total(); }
    friend bool operator<(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() < timestamp2.total(); }
 
    friend bool operator>=(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() >= timestamp2; }
    friend bool operator>=(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 >= timestamp2.total(); }
    friend bool operator>=(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() >= timestamp2.total(); }
 
    friend bool operator<=(const Timestamp& timestamp1, uint64_t timestamp2) noexcept
    { return timestamp1.total() <= timestamp2; }
    friend bool operator<=(uint64_t timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1 <= timestamp2.total(); }
    friend bool operator<=(const Timestamp& timestamp1, const Timestamp& timestamp2) noexcept
    { return timestamp1.total() <= timestamp2.total(); }
 
    std::chrono::system_clock::time_point chrono() const noexcept
    { return std::chrono::time_point_cast<std::chrono::system_clock::duration>((std::chrono::time_point<std::chrono::system_clock>() + std::chrono::nanoseconds(_timestamp))); }
 
    uint64_t days() const noexcept
    { return _timestamp / (24 * 60 * 60 * 1000000000ull); }
    uint64_t hours() const noexcept
    { return _timestamp / (60 * 60 * 1000000000ull); }
    uint64_t minutes() const noexcept
    { return _timestamp / (60 * 1000000000ull); }
    uint64_t seconds() const noexcept
    { return _timestamp / 1000000000; }
    uint64_t milliseconds() const noexcept
    { return _timestamp / 1000000; }
    uint64_t microseconds() const noexcept
    { return _timestamp / 1000; }
    uint64_t nanoseconds() const noexcept
    { return _timestamp; }
 
    uint64_t total() const noexcept { return _timestamp; }
 
    static Timestamp days(int64_t days) noexcept
    { return Timestamp(days * 24 * 60 * 60 * 1000000000ull); }
    static Timestamp hours(int64_t hours) noexcept
    { return Timestamp(hours * 60 * 60 * 1000000000ull); }
    static Timestamp minutes(int64_t minutes) noexcept
    { return Timestamp(minutes * 60 * 1000000000ull); }
    static Timestamp seconds(int64_t seconds) noexcept
    { return Timestamp(seconds * 1000000000); }
    static Timestamp milliseconds(int64_t milliseconds) noexcept
    { return Timestamp(milliseconds * 1000000); }
    static Timestamp microseconds(int64_t microseconds) noexcept
    { return Timestamp(microseconds * 1000); }
    static Timestamp nanoseconds(int64_t nanoseconds) noexcept
    { return Timestamp(nanoseconds); }
 
 
    static uint64_t epoch() noexcept { return 0; }
 
 
    static uint64_t utc();
 
 
    static uint64_t local();
 
 
    static uint64_t nano();
 
 
    static uint64_t rdts();
 
    void swap(Timestamp& timestamp) noexcept;
    friend void swap(Timestamp& timestamp1, Timestamp& timestamp2) noexcept;
 
protected:
    uint64_t _timestamp;
};
 
class EpochTimestamp : public Timestamp
{
public:
    using Timestamp::Timestamp;
 
    EpochTimestamp() : Timestamp(Timestamp::epoch()) {}
    EpochTimestamp(const Timestamp& timestamp) : Timestamp(timestamp) {}
};
 
class UtcTimestamp : public Timestamp
{
public:
    using Timestamp::Timestamp;
 
    UtcTimestamp() : Timestamp(Timestamp::utc()) {}
    UtcTimestamp(const Timestamp& timestamp) : Timestamp(timestamp) {}
};
 
class LocalTimestamp : public Timestamp
{
public:
    using Timestamp::Timestamp;
 
    LocalTimestamp() : Timestamp(Timestamp::local()) {}
    LocalTimestamp(const Timestamp& timestamp) : Timestamp(timestamp) {}
};
 
class NanoTimestamp : public Timestamp
{
public:
    using Timestamp::Timestamp;
 
    NanoTimestamp() : Timestamp(Timestamp::nano()) {}
    NanoTimestamp(const Timestamp& timestamp) : Timestamp(timestamp) {}
};
 
class RdtsTimestamp : public Timestamp
{
public:
    using Timestamp::Timestamp;
 
    RdtsTimestamp() : Timestamp(Timestamp::rdts()) {}
    RdtsTimestamp(const Timestamp& timestamp) : Timestamp(timestamp) {}
};
 
} // namespace CppCommon
 
#include "timestamp.inl"
 
#endif // CPPCOMMON_TIME_TIMESTAMP_H