DateTime.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/PrimitiveTypes.hpp"
#include <ctime>
#include <iostream>
 
#ifndef ARP_INSIDE_ARP_H
    #error Never include 'DateTime.hpp' directly, just include 'Arp.h'
#endif
 
namespace Arp
{
 
 
enum class DateTimeKind
{
    Unspecified = 0,
    Utc = 1,
    // Local = 2
};
 
class DateTime
{
private: // typedefs
    using String = BasicString<char8>;
 
public: // construction/destruction
    DateTime(void);
    ARP_DEPRECATED("Use overload with DateTimeKind parameter instead.")
    explicit DateTime(int64 ticks);
    DateTime(int64 ticks, DateTimeKind kind);
    ARP_DEPRECATED("Use overload with DateTimeKind parameter instead.")
    DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond);
    DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond, DateTimeKind kind);
    DateTime(const DateTime& arg) = default;
    DateTime& operator=(const DateTime& arg) = default;
    ~DateTime(void) = default;
 
public: // operators
    bool operator==(const DateTime& arg)const;
    bool operator!=(const DateTime& arg)const;
    bool operator>(const DateTime& arg)const;
    bool operator<(const DateTime& arg)const;
    bool operator>=(const DateTime& arg)const;
    bool operator<=(const DateTime& arg)const;
 
public: // static operations
    static DateTime GetUtcNow(void);
    ARP_DEPRECATED("Use GetUtcNow instead")
    static DateTime Now(void);
    static DateTime FromUnixTime(time_t unixTime);
    ARP_DEPRECATED("Use FromUnixTimeMicroseconds instead")
    static DateTime FromUnixMicrosecondTicks(uint64 microseconds);
    static DateTime FromUnixTimeMicroseconds(int64 microseconds);
    static DateTime FromOpcUaTime(int64 opcUaTime);
    static DateTime FromIso8601String(const String& value);
    static DateTime FromBinary(uint64 data);
    static bool IsLeapYear(int year);
 
public: // setter/getter operations
    int64           GetTicks(void)const;
    DateTimeKind    GetKind(void)const;
    int             GetYear(void)const;
    int             GetMonth(void)const;
    int             GetDay(void)const;
    int             GetHour(void)const;
    int             GetMinute(void)const;
    int             GetSecond(void)const;
    int             GetMillisecond(void)const;
    int             GetMicrosecond(void)const;
    bool            IsEmpty(void)const;
 
public: // operations
    time_t      ToUnixTime(void)const;
    ARP_DEPRECATED("Use ToUnixTimeMicroseconds instead")
    uint64      ToUnixMicrosecondTicks(void)const;
    int64       ToUnixTimeMicroseconds(void)const;
    uint64      ToBinary(void)const;
    int64       ToOpcUaTime(void)const;
    String      ToIso8601String(void)const;
 
public: // global stream operator for logging and XML conversion
    friend std::ostream& operator<<(std::ostream& os, const DateTime& dateTime);
    friend std::istream& operator>>(std::istream& is, DateTime& dateTime);
 
private: // methods
    int GetDatePart(int part)const;
 
private: // static methods
    static int64 DateToTicks(int year, int month, int day);
    static int64 TimeToTicks(int hour, int minute, int second);
    static int64 TimeToTicks(int hour, int minute, int second, int millisecond, int microsecond);
 
private: // fields
    // The data is stored as an unsigned 64-bit integer
    //   Bits 01-62: The value of 100-nanosecond ticks where 0 represents 1/1/0001 12:00am, up until the value
    //               12/31/9999 23:59:59.9999999
    //   Bits 63-64: A four-state value that describes the DateTimeKind value of the date time.
    uint64 data;
 
private: // static fields
    static const int kindShift = 62;
    static const uint64 kindMask = 3ULL << kindShift;
    static const uint64 ticksMask = ~kindMask;
 
    // Number of 100ns ticks per time unit
    static const int64 ticksPerMicrosecond = 10;
    static const int64 ticksPerMillisecond = ticksPerMicrosecond * 1000;
    static const int64 ticksPerSecond = ticksPerMillisecond * 1000;
    static const int64 ticksPerMinute = ticksPerSecond * 60;
    static const int64 ticksPerHour = ticksPerMinute * 60;
    static const int64 ticksPerDay = ticksPerHour * 24;
 
    // Number of days in a non-leap year
    static const int daysPerYear = 365;
    // Number of days in 4 years
    static const int daysPer4Years = daysPerYear * 4 + 1;
    // Number of days in 100 years
    static const int daysPer100Years = daysPer4Years * 25 - 1;
    // Number of days in 400 years
    static const int daysPer400Years = daysPer100Years * 4 + 1;
 
    // Number of days from 1/1/0001 to 12/31/1969
    static const int daysTo1970 = daysPer400Years * 4 + daysPer100Years * 3 + daysPer4Years * 17 + daysPerYear;
    // Number of days from 1/1/0001 to 12/31/1600
    static const int daysTo1601 = daysPer400Years * 4;
    // Number of days from 1/1/0001 to 12/31/9999
    static const int daysTo10000 = daysPer400Years * 25 - 366;
 
    static const int daysToMonth365[];
    static const int daysToMonth366[];
 
    static const int datePartYear = 0;
    static const int datePartMonth = 2;
    static const int datePartDayOfYear = 1;
    static const int datePartDay = 3;
 
    // Ticks related
    static const int64 unix0Ticks = daysTo1970 * ticksPerDay; // 1970.01.01T 00:00:00
    static const int64 opcua0Ticks = daysTo1601 * ticksPerDay; // 1601.01.01T 00:00:00
 
public: // static fields
    static const int64 MinTicks = 0;
    static const int64 MaxTicks = daysTo10000 * ticksPerDay - 1;
};
 
// inline methods of class DateTime
inline DateTime::DateTime(void)
    : data(0)
{
}
 
inline bool DateTime::operator==(const DateTime& arg) const
{
    return this->GetTicks() == arg.GetTicks();
}
 
inline bool DateTime::operator!=(const DateTime& arg) const
{
    return this->GetTicks() != arg.GetTicks();
}
 
inline bool DateTime::operator>(const DateTime& arg) const
{
    return this->GetTicks() > arg.GetTicks();
}
 
inline bool DateTime::operator<(const DateTime& arg) const
{
    return this->GetTicks() < arg.GetTicks();
}
 
inline bool DateTime::operator>=(const DateTime& arg) const
{
    return this->GetTicks() >= arg.GetTicks();
}
 
inline bool DateTime::operator<=(const DateTime& arg) const
{
    return this->GetTicks() <= arg.GetTicks();
}
 
inline int64 DateTime::GetTicks() const
{
    return (int64)(this->data & ticksMask);
}
 
inline DateTimeKind DateTime::GetKind() const
{
    return (DateTimeKind)(this->data >> kindShift);
}
 
inline DateTime DateTime::FromUnixMicrosecondTicks(uint64 microseconds)
{
    return DateTime(unix0Ticks + (uint64)microseconds * ticksPerMicrosecond, DateTimeKind::Utc);
}
 
inline std::ostream& operator<<(std::ostream& os, const DateTime& dateTime)
{
    os << dateTime.ToIso8601String();
    return os;
}
 
inline std::istream& operator>>(std::istream& is, DateTime& dateTime)
{
    std::string s;
    is >> s;
    dateTime = DateTime::FromIso8601String(s);
    return is;
}
 
 
} // end of namespace Arp