Time.h

 
#ifndef ACTIVE_UTILITY_TIME
#define ACTIVE_UTILITY_TIME
 
#include "Active/Utility/MathFunctions.h"
 
#include <chrono>
#include <compare>
#include <filesystem>
#include <optional>
 
namespace active::utility {
    
    class Time {
    public:
        
        // MARK: Constants
        
        inline static constexpr uint8_t minDay = 1;
        inline static constexpr uint8_t maxDay = 31;
        inline static constexpr uint8_t minMonth = 1;
        inline static constexpr uint8_t maxMonth = 12;
        inline static constexpr uint8_t maxHour = 23;
        inline static constexpr uint8_t maxMinute = 59;
        inline static constexpr uint8_t maxSecond = 59;
        
        // MARK: - Types
        
        using Option = std::optional<Time>;
 
        // MARK: - Constructors
        
        Time(bool isUTCTime = true);
        Time(std::filesystem::file_time_type fileTime);
        Time(time_t time);
#if !defined(WINDOWS) && !defined(__linux__)
        Time(int64_t seconds) : Time{static_cast<time_t>(seconds)} {}
#endif //WINDOWS
        Time(double seconds) : Time{static_cast<time_t>(seconds)} {
            m_microsecond = static_cast<int32_t>(1e6 * fmod(seconds, 1.0));
        }
        Time(int32_t year, std::chrono::month month, uint8_t day, uint8_t hour = 0, uint8_t minute = 0, double second = 0, int16_t utcOffset = 0);
        
        // MARK: - Operators
        
        Time& operator=(const std::chrono::system_clock::time_point& source);
        std::strong_ordering operator<=>(const Time& ref) const { return compare(ref); }
        bool operator==(const Time& ref) const { return compare(ref) == std::strong_ordering::equal; }
        bool operator!=(const Time& ref) const { return !(*this == ref); }
        Time& operator+=(int32_t days);
        operator std::chrono::system_clock::time_point() const;
        
        // MARK: - Functions (const)
        
        std::strong_ordering compare(const Time& ref, std::optional<double> epsMicrosec = std::nullopt) const;
        int64_t year() const { return m_year; }
        std::chrono::month month() const { return std::chrono::month{m_month}; }
        uint8_t day() const { return m_day; }
        uint8_t hour() const { return m_hour; }
        uint8_t minute() const { return m_minute; }
        uint8_t second() const { return m_second; }
        uint32_t microsecond() const { return m_microsecond; }
        std::pair<int16_t, int16_t> getUTCOffset() const;
        double secondsSince1970() const;
        double differenceInSeconds(const Time& other) const;
        int64_t differenceInMinutes(const Time& other) const;
        int64_t differenceInHours(const Time& other) const;
        int64_t differenceInDays(const Time& other) const;
        
        // MARK: - Functions (mutating)
        
        Time& setToCurrent(bool isUTCTime = true);
        Time& resetTime();
        Time& resetDate();
        Time& addDays(int16_t daystoAdd);
        Time& addHours(int16_t hourstoAdd);
        Time& addMinutes(int16_t minstoAdd);
        Time& addSeconds(double secsToAdd);
        void setHour(uint8_t val) { m_hour = static_cast<uint8_t>(std::min(val, maxHour)); }
        void setMinute(uint8_t val) { m_minute = static_cast<uint8_t>(std::min(val, maxMinute));}
        void setSecond(uint8_t val) { m_second = static_cast<uint8_t>(std::min(val, maxSecond)); }
        void setMicrosecond(uint32_t val) { m_microsecond = val; }
        void setUTCOffset(int16_t offset) { m_utcOffset = offset; }
        void setSecondsSince1970(double totalSeconds);
        
    private:
        std::chrono::system_clock::time_point makeTimePoint(std::optional<double> prec = std::nullopt) const;
        void testValidity();
        
        // MARK: - Variables
        
        int64_t m_utcOffset : 12 = 0;
        int64_t m_year : 52 = 0;
        uint8_t m_month = minMonth;
        uint8_t m_day = minDay;
        uint8_t m_hour = 0;
        uint8_t m_minute = 0;
        uint32_t m_second : 8 = 0;
        uint32_t m_microsecond : 24 = 0;
    };
 
}
 
#endif  //ACTIVE_UTILITY_TIME