time.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_TIME_TIME_H
#define CPPCOMMON_TIME_TIME_H
 
#include "time/timestamp.h"
 
namespace CppCommon {
 
enum class Weekday
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
};
 
 
template <class TOutputStream>
TOutputStream& operator<<(TOutputStream& stream, Weekday weekday);
 
 
class Time
{
public:
    Time() noexcept;
 
    explicit Time(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microsecond = 0, int nanosecond = 0);
    Time(const Time&) noexcept = default;
    Time(Time&&) noexcept = default;
    ~Time() noexcept = default;
 
    Time& operator=(const Timestamp& timestamp)
    { return operator=(Time(timestamp)); }
    Time& operator=(const Time&) noexcept = default;
    Time& operator=(Time&&) noexcept = default;
 
    // Time offset operations
    Time& operator+=(const Timespan& offset)
    { return operator=(Time(utcstamp() + offset)); }
 
    Time& operator-=(const Timespan& offset)
    { return operator=(Time(utcstamp() - offset)); }
 
    friend Time operator+(const Time& time, const Timespan& offset)
    { return Time(time.utcstamp() + offset); }
    friend Time operator+(const Timespan& offset, const Time& time)
    { return Time(offset + time.utcstamp()); }
 
    friend Time operator-(const Time& time, const Timespan& offset)
    { return Time(time.utcstamp() - offset); }
    friend Time operator-(const Timespan& offset, const Time& time)
    { return Time(offset - time.utcstamp()); }
 
    friend Timespan operator-(const Time& time1, const Time& time2)
    { return time1.utcstamp() - time2.utcstamp(); }
 
    // Time comparison
    friend bool operator==(const Time& time, const Timestamp& timestamp)
    { return time == Time(timestamp); }
    friend bool operator==(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) == time; }
    friend bool operator==(const Time& time1, const Time& time2) noexcept;
 
    friend bool operator!=(const Time& time, const Timestamp& timestamp)
    { return time != Time(timestamp); }
    friend bool operator!=(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) != time; }
    friend bool operator!=(const Time& time1, const Time& time2) noexcept;
 
    friend bool operator>(const Time& time, const Timestamp& timestamp)
    { return time > Time(timestamp); }
    friend bool operator>(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) > time; }
    friend bool operator>(const Time& time1, const Time& time2) noexcept;
 
    friend bool operator<(const Time& time, const Timestamp& timestamp)
    { return time < Time(timestamp); }
    friend bool operator<(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) < time; }
    friend bool operator<(const Time& time1, const Time& time2) noexcept;
 
    friend bool operator>=(const Time& time, const Timestamp& timestamp)
    { return time >= Time(timestamp); }
    friend bool operator>=(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) >= time; }
    friend bool operator>=(const Time& time1, const Time& time2) noexcept;
 
    friend bool operator<=(const Time& time, const Timestamp& timestamp)
    { return time <= Time(timestamp); }
    friend bool operator<=(const Timestamp& timestamp, const Time& time)
    { return Time(timestamp) <= time; }
    friend bool operator<=(const Time& time1, const Time& time2) noexcept;
 
    std::chrono::time_point<std::chrono::system_clock> chrono() const
    { return utcstamp().chrono(); }
 
    int year() const noexcept { return _year; }
    int month() const noexcept { return _month; }
    Weekday weekday() const noexcept { return (Weekday)_weekday; }
    int day() const noexcept { return _day; }
    int hour() const noexcept { return _hour; }
    int minute() const noexcept { return _minute; }
    int second() const noexcept { return _second; }
    int millisecond() const noexcept { return _millisecond; }
    int microsecond() const noexcept { return _microsecond; }
    int nanosecond() const noexcept { return _nanosecond; }
 
    UtcTimestamp utcstamp() const;
    LocalTimestamp localstamp() const;
 
 
    static Time epoch()
    { return Time(1970, 1, 1); }
 
    void swap(Time& time) noexcept;
    friend void swap(Time& time1, Time& time2) noexcept;
 
protected:
    int _year;
    int _month;
    int _weekday;
    int _day;
    int _hour;
    int _minute;
    int _second;
    int _millisecond;
    int _microsecond;
    int _nanosecond;
 
 
    explicit Time(const Timestamp& timestamp);
};
 
// Forward class declarations
class UtcTime;
class LocalTime;
 
class UtcTime : public Time
{
public:
    using Time::Time;
    using Time::chrono;
 
    UtcTime() : UtcTime(UtcTimestamp()) {}
 
    explicit UtcTime(const Timestamp& timestamp);
 
    template <class Clock, class Duration>
    explicit UtcTime(const std::chrono::time_point<Clock, Duration>& time_point) : UtcTime(Timestamp(time_point)) {}
    UtcTime(const Time& time) : Time(time) {}
    UtcTime(const LocalTime& time);
};
 
class LocalTime : public Time
{
public:
    using Time::Time;
    using Time::chrono;
 
    LocalTime() : LocalTime(UtcTimestamp()) {}
 
    explicit LocalTime(const Timestamp& timestamp);
 
    template <class Clock, class Duration>
    explicit LocalTime(const std::chrono::time_point<Clock, Duration>& time_point) : LocalTime(Timestamp(time_point)) {}
    LocalTime(const Time& time) : Time(time) {}
    LocalTime(const UtcTime& time);
};
 
} // namespace CppCommon
 
#include "time.inl"
 
#endif // CPPCOMMON_TIME_TIME_H