time.hpp

/*
 * Copyright (c) 2024 Abdullatif Kalla.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
 
#ifndef XCLOX_TIME_HPP
#define XCLOX_TIME_HPP
 
#include "internal.hpp"
 
namespace xclox {
 
class Time {
    using Duration = std::chrono::nanoseconds;
    using Days = internal::Days;
 
public:
    using Nanoseconds = std::chrono::nanoseconds; 
    using Microseconds = std::chrono::microseconds; 
    using Milliseconds = std::chrono::milliseconds; 
    using Seconds = std::chrono::seconds; 
    using Minutes = std::chrono::minutes; 
    using Hours = std::chrono::hours; 
 
 
    Time()
        : m_duration(Hours(24))
    {
    }
 
    Time(const Time& other) = default;
 
    Time(Time&& other) = default;
 
    explicit Time(std::time_t scalarStdTime)
        : m_duration(Seconds(scalarStdTime))
    {
    }
 
    explicit Time(const std::tm& brokenStdTime)
        : m_duration(Hours(brokenStdTime.tm_hour) + Minutes(brokenStdTime.tm_min) + Seconds(brokenStdTime.tm_sec))
    {
    }
 
    explicit Time(const Duration& duration)
        : m_duration(duration)
    {
    }
 
    explicit Time(const std::chrono::system_clock::time_point& timePoint)
        : m_duration(timePoint.time_since_epoch() % Days(1))
    {
    }
 
    explicit Time(int hours, int minutes, int seconds)
        : m_duration(Hours(hours) + Minutes(minutes) + Seconds(seconds))
    {
    }
 
    explicit Time(int hours, int minutes, int seconds, int milliseconds)
        : m_duration(Hours(hours) + Minutes(minutes) + Seconds(seconds) + Milliseconds(milliseconds))
    {
    }
 
    explicit Time(int hours, int minutes, int seconds, const Duration& subseconds)
        : m_duration(Hours(hours) + Minutes(minutes) + Seconds(seconds) + subseconds)
    {
    }
 
    explicit Time(Hours hours, Minutes minutes, Seconds seconds, const Duration& subseconds)
        : m_duration(hours + minutes + seconds + subseconds)
    {
    }
 
    ~Time() = default;
 
 
    Time& operator=(const Time& other) = default;
 
    Time& operator=(Time&& other) = default;
 
 
    bool operator<(const Time& other) const
    {
        return this->m_duration < other.m_duration;
    }
 
    bool operator<=(const Time& other) const
    {
        return this->m_duration <= other.m_duration;
    }
 
    bool operator>(const Time& other) const
    {
        return this->m_duration > other.m_duration;
    }
 
    bool operator>=(const Time& other) const
    {
        return this->m_duration >= other.m_duration;
    }
 
    bool operator==(const Time& other) const
    {
        return this->m_duration == other.m_duration;
    }
 
    bool operator!=(const Time& other) const
    {
        return this->m_duration != other.m_duration;
    }
 
 
    Time operator+(const Duration& duration) const
    {
        return Time(this->m_duration + duration);
    }
 
    Time operator-(const Duration& duration) const
    {
        return Time(this->m_duration - duration);
    }
 
    Nanoseconds operator-(const Time& other) const
    {
        return Nanoseconds(this->m_duration - other.m_duration);
    }
 
 
    bool isValid() const
    {
        return m_duration.count() >= 0 && m_duration < Days(1);
    }
 
    long nanosecond() const
    {
        return static_cast<long>(std::chrono::duration_cast<Nanoseconds>(m_duration % Seconds(1)).count());
    }
 
    long microsecond() const
    {
        return static_cast<long>(std::chrono::duration_cast<Microseconds>(m_duration % Seconds(1)).count());
    }
 
    int millisecond() const
    {
        return static_cast<int>(std::chrono::duration_cast<Milliseconds>(m_duration % Seconds(1)).count());
    }
 
    int second() const
    {
        return static_cast<int>(std::chrono::duration_cast<Seconds>(m_duration % Minutes(1)).count());
    }
 
    int minute() const
    {
        return std::chrono::duration_cast<Minutes>(m_duration % Hours(1)).count();
    }
 
    int hour() const
    {
        return std::chrono::duration_cast<Hours>(m_duration % Days(1)).count();
    }
 
 
    Time addNanoseconds(int nanoseconds) const
    {
        return Time(m_duration + Nanoseconds(nanoseconds));
    }
 
    Time subtractNanoseconds(int nanoseconds) const
    {
        return Time(m_duration - Nanoseconds(nanoseconds));
    }
 
    Time addMicroseconds(int microseconds) const
    {
        return Time(m_duration + Microseconds(microseconds));
    }
 
    Time subtractMicroseconds(int microseconds) const
    {
        return Time(m_duration - Microseconds(microseconds));
    }
 
    Time addMilliseconds(int milliseconds) const
    {
        return Time(m_duration + Milliseconds(milliseconds));
    }
 
    Time subtractMilliseconds(int milliseconds) const
    {
        return Time(m_duration - Milliseconds(milliseconds));
    }
 
    Time addSeconds(int seconds) const
    {
        return Time(m_duration + Seconds(seconds));
    }
 
    Time subtractSeconds(int seconds) const
    {
        return Time(m_duration - Seconds(seconds));
    }
 
    Time addMinutes(int minutes) const
    {
        return Time(m_duration + Minutes(minutes));
    }
 
    Time subtractMinutes(int minutes) const
    {
        return Time(m_duration - Minutes(minutes));
    }
 
    Time addHours(int hours) const
    {
        return Time(m_duration + Hours(hours));
    }
 
    Time subtractHours(int hours) const
    {
        return Time(m_duration - Hours(hours));
    }
 
    Time addDuration(const Duration& duration) const
    {
        return Time(m_duration + duration);
    }
 
    Time subtractDuration(const Duration& duration) const
    {
        return Time(m_duration - duration);
    }
 
 
    long long toNanosecondsSinceMidnight() const
    {
        return std::chrono::duration_cast<Nanoseconds>(m_duration).count();
    }
 
    long long toMicrosecondsSinceMidnight() const
    {
        return std::chrono::duration_cast<Microseconds>(m_duration).count();
    }
 
    long toMillisecondsSinceMidnight() const
    {
        return static_cast<long>(std::chrono::duration_cast<Milliseconds>(m_duration).count());
    }
 
    long toSecondsSinceMidnight() const
    {
        return static_cast<long>(std::chrono::duration_cast<Seconds>(m_duration).count());
    }
 
    int toMinutesSinceMidnight() const
    {
        return std::chrono::duration_cast<Minutes>(m_duration).count();
    }
 
    int toHoursSinceMidnight() const
    {
        return std::chrono::duration_cast<Hours>(m_duration).count();
    }
 
    Nanoseconds toStdDurationSinceMidnight() const
    {
        return m_duration;
    }
 
    std::tm toBrokenStdTime() const
    {
        std::tm cTime = { 0 };
        cTime.tm_hour = hour();
        cTime.tm_min = minute();
        cTime.tm_sec = second();
        return cTime;
    }
 
    std::time_t toScalarStdTime() const
    {
        return std::time_t(toSecondsSinceMidnight());
    }
 
    std::string toString(const std::string& format) const
    {
        if (!isValid())
            return std::string();
 
        std::stringstream output;
 
        for (size_t pos = 0; pos < format.size(); ++pos) {
            const int patternLength = internal::countIdenticalCharsFrom(pos, format);
 
            if (format[pos] == 'h') {
                output << std::setfill('0') << std::setw(patternLength) << hour();
                pos += patternLength - 1; // skip all identical characters except the last.
            } else if (format[pos] == 'H') {
                int hours12f = ((hour() == 0 || hour() == 12) ? 12 : hour() % 12);
                output << std::setfill('0') << std::setw(patternLength) << hours12f;
                pos += patternLength - 1;
            } else if (format[pos] == 'm') {
                output << std::setfill('0') << std::setw(patternLength) << minute();
                pos += patternLength - 1;
            } else if (format[pos] == 's') {
                output << std::setfill('0') << std::setw(patternLength) << second();
                pos += patternLength - 1;
            } else if (format[pos] == 'f') {
                std::string subseconds = std::to_string(std::chrono::duration_cast<Nanoseconds>(m_duration % Seconds(1)).count());
                std::string padddedSubsecondsString = subseconds.insert(0, 9 - subseconds.size(), '0');
                output << padddedSubsecondsString.substr(0, static_cast<size_t>(patternLength));
                pos += patternLength - 1;
            } else if (format[pos] == 'A') {
                output << (hour() >= 12 ? "PM" : "AM");
            } else if (format[pos] == 'a') {
                output << (hour() >= 12 ? "pm" : "am");
            } else {
                output << format[pos];
            }
        }
 
        return output.str();
    }
 
 
    static Time current()
    {
        return Time(std::chrono::duration_cast<Nanoseconds>(std::chrono::system_clock::now().time_since_epoch() % Days(1)));
    }
 
    static Time midnight()
    {
        return Time(Nanoseconds::zero());
    }
 
    static Time fromString(const std::string& time, const std::string& format)
    {
        int _hour = 0, _minute = 0, _second = 0;
        long _subsecond = 0;
 
        for (size_t fmtPos = 0, timPos = 0; fmtPos < format.size() && timPos < time.size(); ++fmtPos) {
            const int patternLength = internal::countIdenticalCharsFrom(fmtPos, format);
 
            if (format[fmtPos] == 'h' || format[fmtPos] == 'H') {
                _hour = internal::readIntAndAdvancePos(time, timPos, 2);
                fmtPos += patternLength - 1; // skip all identical characters except the last.
            } else if (format[fmtPos] == 'm') {
                _minute = internal::readIntAndAdvancePos(time, timPos, 2);
                fmtPos += patternLength - 1;
            } else if (format[fmtPos] == 's') {
                _second = internal::readIntAndAdvancePos(time, timPos, 2);
                fmtPos += patternLength - 1;
            } else if (format[fmtPos] == 'f') {
                std::string subsecondString = time.substr(timPos, static_cast<size_t>(patternLength));
                _subsecond = std::stoi(subsecondString.append(9 - subsecondString.size(), '0'));
                timPos += patternLength;
                fmtPos += patternLength - 1;
            } else if (format[fmtPos] == 'a' || format[fmtPos] == 'A') {
                if (time.substr(timPos, 2) == "pm" || time.substr(timPos, 2) == "PM") {
                    _hour = (_hour > 12 ? _hour : _hour + 12);
                    timPos += 2;
                }
            } else {
                ++timPos;
            }
        }
 
        return Time(Hours(_hour) + Minutes(_minute) + Seconds(_second) + Nanoseconds(_subsecond));
    }
 
    static long long nanosecondsBetween(const Time& from, const Time& to)
    {
        return to.toNanosecondsSinceMidnight() - from.toNanosecondsSinceMidnight();
    }
 
    static long long microsecondsBetween(const Time& from, const Time& to)
    {
        return to.toMicrosecondsSinceMidnight() - from.toMicrosecondsSinceMidnight();
    }
 
    static long millisecondsBetween(const Time& from, const Time& to)
    {
        return to.toMillisecondsSinceMidnight() - from.toMillisecondsSinceMidnight();
    }
 
    static long secondsBetween(const Time& from, const Time& to)
    {
        return to.toSecondsSinceMidnight() - from.toSecondsSinceMidnight();
    }
 
    static int minutesBetween(const Time& from, const Time& to)
    {
        return to.toMinutesSinceMidnight() - from.toMinutesSinceMidnight();
    }
 
    static int hoursBetween(const Time& from, const Time& to)
    {
        return to.toHoursSinceMidnight() - from.toHoursSinceMidnight();
    }
 
 
private:
    Duration m_duration;
};
 
std::ostream& operator<<(std::ostream& os, const Time& t)
{
    os << t.toString("hh:mm:ss.fff");
    return os;
}
 
std::istream& operator>>(std::istream& is, Time& t)
{
    const int TimeFormatWidth = 12;
    char result[TimeFormatWidth];
    is.read(result, TimeFormatWidth);
 
    t = Time::fromString(std::string(result, TimeFormatWidth), "hh:mm:ss.fff");
    return is;
}
 
 
} // namespace xclox
 
#endif // XCLOX_TIME_HPP