datetime.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External includes
#include <chrono>
#include <stdint.h>
#include <string>
#include <ctime>
#include <functional>
#include <utility/dllexport.h>
#include <rtti/typeinfo.h>
 
namespace nap
{
    // Typedefs
    using SystemClock = std::chrono::system_clock;                          
    using HighResolutionClock = std::chrono::high_resolution_clock;         
    using SteadyClock = std::chrono::steady_clock;                          
    using Milliseconds = std::chrono::milliseconds;                         
    using MicroSeconds = std::chrono::microseconds;                         
    using NanoSeconds = std::chrono::nanoseconds;                           
    using Seconds = std::chrono::seconds;                                   
    using Minutes = std::chrono::minutes;                                   
    using Hours = std::chrono::hours;                                       
    using SystemTimeStamp = std::chrono::time_point<SystemClock>;           
    using HighResTimeStamp = std::chrono::time_point<HighResolutionClock>;  
    using SteadyTimeStamp = std::chrono::time_point<SteadyClock>;           
 
    // Forward declares
    class DateTime;
 
 
    // Utility
 
    NAPAPI SystemTimeStamp getCurrentTime();
 
    NAPAPI DateTime getCurrentDateTime();
 
    NAPAPI void getCurrentDateTime(DateTime& outDateTime);
 
    NAPAPI std::string timeFormat(const SystemTimeStamp& time, const std::string& format = "%Y-%m-%d %H:%M:%S.%ms");
 
    NAPAPI SystemTimeStamp createTimestamp(int year, int month, int day, int hour, int minute, int second=0, int millisecond=0, bool daylightSaving = true);
 
 
    // Day
 
    enum class EDay : int
    {
        Monday      = 1,        
        Tuesday     = 2,        
        Wednesday   = 3,        
        Thursday    = 4,        
        Friday      = 5,        
        Saturday    = 6,        
        Sunday      = 0,        
        Unknown     = -1        
    };
 
    NAPAPI const std::array<EDay,7>& getDaysInWeek();
 
    NAPAPI std::string toString(EDay day);
 
    NAPAPI EDay toDay(const std::string& string);
 
 
    // Month
 
    enum class EMonth : int
    {
        January     = 1,        
        February    = 2,        
        March       = 3,        
        April       = 4,        
        May         = 5,        
        June        = 6,        
        July        = 7,        
        August      = 8,        
        September   = 9,        
        October     = 10,       
        November    = 11,       
        December    = 12,       
        Unknown     = -1        
    };
    
    NAPAPI std::string toString(EMonth month);
 
    NAPAPI EMonth toMonth(const std::string& string);
 
 
    // DateTime
 
    class NAPAPI DateTime final
    {
    public:
 
        enum class ConversionMode : int
        {
            Local = 0,      
            GMT = 1         
        };
 
    public:
        DateTime();
 
        DateTime(const SystemTimeStamp& timeStamp, ConversionMode mode);
 
        DateTime(const SystemTimeStamp& timeStamp);
 
        // Default destructor
        ~DateTime() = default;
 
        int getYear() const;
 
        EMonth getMonth() const;
 
        int getWeek() const;
 
        int getDayInTheMonth() const;
 
        int getDayInTheYear() const;
 
        EDay getDay() const;
 
        int getHour() const;
 
        int getMinute() const;
 
        int getSecond() const;
 
        int getMilliSecond() const;
 
        bool isDaylightSaving() const;
 
        std::string toString() const;
 
        void setTimeStamp(const SystemTimeStamp& timeStamp);
 
        const SystemTimeStamp& getTimeStamp() const { return mTimeStamp; }
 
        // Allows for DateTime to be compared
        bool operator<(const DateTime& other) const { return this->mTimeStamp < other.mTimeStamp; }
        bool operator==(const DateTime& other) const { return this->mTimeStamp == other.mTimeStamp; }
        bool operator!=(const DateTime& other) const { return this->mTimeStamp != other.mTimeStamp; }
        bool operator<=(const DateTime& other) const { return this->mTimeStamp <= other.mTimeStamp; }
        bool operator>=(const DateTime& other) const { return this->mTimeStamp >= other.mTimeStamp; }
 
    private:
 
        SystemTimeStamp     mTimeStamp = SystemClock::now();    
        std::tm             mTimeStruct;                        
        ConversionMode      mMode = ConversionMode::Local;      
    };
 
 
    // Date
 
    class NAPAPI Date final
    {
        RTTI_ENABLE()
    public:
        Date() = default;
 
        Date(int year, EMonth month, int day);
 
        Date(const SystemTimeStamp& systemTime);
 
        void fromSystemTime(const SystemTimeStamp& systemTime);
 
        SystemTimeStamp toSystemTime() const;
 
        static bool exists(int year, EMonth month, int day);
 
        bool valid() const;
 
        EMonth mMonth = EMonth::Unknown;            
        int mDay = 1;                               
        int mYear = 1970;                           
    };
 
 
    // Timestamp
 
    class NAPAPI TimeStamp final
    {
        RTTI_ENABLE()
    public:
        TimeStamp() = default;
 
        TimeStamp(int64_t timeStamp) : mTimeStamp(timeStamp)    { }
 
        TimeStamp(const SystemTimeStamp& systemTime);
 
        void fromSystemTime(const SystemTimeStamp& systemTime);
 
        SystemTimeStamp toSystemTime() const;
 
        inline bool isValid() const { return mTimeStamp >= 0; }
 
        int64_t mTimeStamp = -1;        
    };
}
 
 
// Hashes
 
namespace std
{
    template <>
    struct hash<nap::EDay>
    {
        size_t operator()(const nap::EDay& v) const
        {
            return std::hash<int>()(static_cast<int>(v));
        }
    };
 
    template <>
    struct hash<nap::EMonth>
    {
        size_t operator()(const nap::EMonth& v) const
        {
            return std::hash<int>()(static_cast<int>(v));
        }
    };
}