date_time.h

 
#pragma once
 
#include <system/date_time_kind.h>
#include <system/day_of_week.h>
#include <system/timespan.h>
#include <system/boxable_traits.h>
#include <system/globalization/date_time_styles.h>
#include <functional>
#include <memory>
 
namespace System {
 
namespace Globalization { 
    class Calendar;
    class CultureInfo;
    class DateTimeFormatInfo;
}
 
class ASPOSECPP_SHARED_CLASS DateTime final
{
public:
    // Number of 100ns ticks per time unit
    static constexpr int64_t TicksPerMicrosecond = 10;
    static constexpr int64_t TicksPerMillisecond = 10000;
    static constexpr int64_t TicksPerSecond = TicksPerMillisecond * 1000;
    static constexpr int64_t TicksPerMinute = TicksPerSecond * 60;
    static constexpr int64_t TicksPerHour = TicksPerMinute * 60;
    static constexpr int64_t TicksPerDay = TicksPerHour * 24;
 
    static constexpr int64_t MinTicks = 0;
    static constexpr int64_t MaxTicks = 3652059 * TicksPerDay - 1;
 
    static ASPOSECPP_SHARED_API const DateTime MinValue;
 
    static ASPOSECPP_SHARED_API const DateTime MaxValue;
 
    static ASPOSECPP_SHARED_API const DateTime UnixEpoch;
 
    constexpr DateTime() : m_data(0) {}
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, const SharedPtr<Globalization::Calendar>& calendar);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, int hour, int minute, int second);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, int hour, int minute, int second, const SharedPtr<Globalization::Calendar>& calendar);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind = DateTimeKind::Unspecified);
 
    ASPOSECPP_SHARED_API DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, const SharedPtr<Globalization::Calendar>& calendar, DateTimeKind kind = DateTimeKind::Unspecified);
 
    ASPOSECPP_SHARED_API DateTime(int64_t ticks, DateTimeKind kind = DateTimeKind::Unspecified);
 
    DateTime(int64_t ticks, DateTimeKind kind, bool is_ambiguous_local_dst);
 
    DateTime(const DateTime& dt) = default;
 
    DateTime& operator=(const DateTime& dt) = default;
 
    constexpr DateTime get_Date() const
    {
        const int64_t ticks = get_Ticks();
        return DateTime(static_cast<uint64_t>(ticks - (ticks % TicksPerDay)) | Flags(), InternalConstructor);
    }
 
    constexpr DayOfWeek get_DayOfWeek() const
    {
        return static_cast<DayOfWeek>((get_Ticks() / TicksPerDay + 1) % 7);
    }
 
    constexpr DateTimeKind get_Kind() const
    {
        return static_cast<DateTimeKind>(std::min(2, static_cast<int>(m_data >> 62)));
    }
 
    constexpr TimeSpan get_TimeOfDay() const
    {
        return TimeSpan(get_Ticks() % TicksPerDay);
    }
 
    ASPOSECPP_SHARED_API int get_DayOfYear() const;
 
    ASPOSECPP_SHARED_API int get_Year() const;
        
    ASPOSECPP_SHARED_API int get_Month() const;
 
    ASPOSECPP_SHARED_API int get_Day() const;
 
    void GetDateComponents(int& year, int& month, int& day) const;
 
    constexpr int get_Hour() const
    {
        return static_cast<int>((get_Ticks() / TicksPerHour) % 24);
    }
        
    constexpr int get_Minute() const
    {
        return static_cast<int>((get_Ticks() / TicksPerMinute) % 60);
    }
 
    constexpr int get_Second() const
    {
        return static_cast<int>((get_Ticks() / TicksPerSecond) % 60);
    }
 
    constexpr int get_Millisecond() const
    {
        return static_cast<int>((get_Ticks() / TicksPerMillisecond) % 1000);
    }
 
    constexpr int64_t get_Ticks() const
    {
        return static_cast<int64_t>(m_data & TicksMask);
    }
 
    static ASPOSECPP_SHARED_API DateTime get_Now();
 
    static ASPOSECPP_SHARED_API DateTime get_UtcNow();
 
    static ASPOSECPP_SHARED_API DateTime get_Today();
 
    ASPOSECPP_SHARED_API DateTime Add(TimeSpan value) const;
 
    ASPOSECPP_SHARED_API DateTime AddYears(int value) const;
 
    ASPOSECPP_SHARED_API DateTime AddMonths(int value) const;
 
    ASPOSECPP_SHARED_API DateTime AddDays(double value) const;
 
    ASPOSECPP_SHARED_API DateTime AddHours(double value) const;
 
    ASPOSECPP_SHARED_API DateTime AddMinutes(double value) const;
 
    ASPOSECPP_SHARED_API DateTime AddSeconds(double value) const;
 
    ASPOSECPP_SHARED_API DateTime AddMilliseconds(double value) const;
 
    ASPOSECPP_SHARED_API DateTime AddTicks(int64_t value) const;
 
    ASPOSECPP_SHARED_API DateTime Subtract(TimeSpan duration) const;
 
    constexpr TimeSpan Subtract(DateTime value) const
    {
        return TimeSpan(get_Ticks() - value.get_Ticks());
    }
 
    ASPOSECPP_SHARED_API DateTime ToLocalTime() const;
 
    ASPOSECPP_SHARED_API DateTime ToUniversalTime() const;
 
    time_t ToUnixTime() const;
 
    ASPOSECPP_SHARED_API int64_t ToFileTime() const;
 
    ASPOSECPP_SHARED_API int64_t ToFileTimeUtc() const;
 
    ASPOSECPP_SHARED_API int64_t ToBinary() const;
 
    ASPOSECPP_SHARED_API double ToOADate() const;
 
    static ASPOSECPP_SHARED_API DateTime FromBinary(int64_t value);
 
    static ASPOSECPP_SHARED_API DateTime FromFileTimeUtc(int64_t file_time);
 
    static ASPOSECPP_SHARED_API DateTime FromOADate(double date);
 
    static DateTime FromUnixTime(time_t value);
 
    static ASPOSECPP_SHARED_API DateTime FromFileTime(int64_t value);
 
    static ASPOSECPP_SHARED_API int DaysInMonth(int year, int month);
 
    static ASPOSECPP_SHARED_API bool IsLeapYear(int year);
 
    ASPOSECPP_SHARED_API bool IsDaylightSavingTime() const;
 
    static DateTime SpecifyKind(DateTime value, DateTimeKind kind)
    {
        return DateTime(value.get_Ticks(), kind);
    }
 
    static constexpr int Compare(DateTime t1, DateTime t2)
    {
        return (t1 < t2 ? -1 : (t2 < t1 ? 1 : 0));
    }
 
    constexpr int CompareTo(DateTime value) const
    {
        return Compare(*this, value);
    }
 
    static constexpr bool Equals(DateTime t1, DateTime t2)
    {
        return t1.get_Ticks() == t2.get_Ticks();
    }
 
    constexpr bool Equals(DateTime other) const
    {
        return get_Ticks() == other.get_Ticks();
    }
 
    ASPOSECPP_SHARED_API int GetHashCode() const;
 
    ASPOSECPP_SHARED_API String ToString() const;
 
    ASPOSECPP_SHARED_API String ToString(const String& format) const;
 
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<IFormatProvider>& provider) const;
    // Optimized function overloads
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<Globalization::CultureInfo>& culture) const;
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi) const;
    String ToString(std::nullptr_t) const { return ToString(); }
 
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<IFormatProvider>& provider) const;
    // Optimized function overloads
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<Globalization::CultureInfo>& culture) const;
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi) const;
    String ToString(const String& format, std::nullptr_t) const { return ToString(format); }
 
    ASPOSECPP_SHARED_API String ToShortDateString() const;
 
    ASPOSECPP_SHARED_API String ToLongDateString() const;
 
    ASPOSECPP_SHARED_API String ToShortTimeString() const;
 
    ASPOSECPP_SHARED_API String ToLongTimeString() const;
 
    ASPOSECPP_SHARED_API ArrayPtr<String> GetDateTimeFormats() const;
    ASPOSECPP_SHARED_API ArrayPtr<String> GetDateTimeFormats(char_t format) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> GetDateTimeFormats(const SharedPtr<IFormatProvider>& provider) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> GetDateTimeFormats(char_t format, const SharedPtr<IFormatProvider>& provider) const;
 
    static ASPOSECPP_SHARED_API DateTime Parse(const String& s);
 
    static ASPOSECPP_SHARED_API DateTime Parse(const String& s, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API DateTime Parse(const String& s, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    static ASPOSECPP_SHARED_API DateTime Parse(const String& s, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    static ASPOSECPP_SHARED_API DateTime Parse(const String& s, std::nullptr_t, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
 
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const String& format, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const String& format, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const String& format, std::nullptr_t, Globalization::DateTimeStyles styles = Globalization::DateTimeStyles::None);
 
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles);
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles);
    static ASPOSECPP_SHARED_API DateTime ParseExact(const String& s, const ArrayPtr<String>& formats, std::nullptr_t, Globalization::DateTimeStyles styles);
 
    static ASPOSECPP_SHARED_API bool TryParse(const String& s, DateTime& result);
 
    static ASPOSECPP_SHARED_API bool TryParse(const String& s, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles, DateTime& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParse(const String& s, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParse(const String& s, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParse(const String& s, std::nullptr_t, Globalization::DateTimeStyles styles, DateTime& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const String& format, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles, DateTime& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const String& format, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const String& format, std::nullptr_t, Globalization::DateTimeStyles styles, DateTime& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<IFormatProvider>& provider, Globalization::DateTimeStyles styles, DateTime& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const ArrayPtr<String>& formats, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::DateTimeStyles styles, DateTime& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& s, const ArrayPtr<String>& formats, std::nullptr_t, Globalization::DateTimeStyles styles, DateTime& result);
 
    constexpr bool operator==(DateTime other) const
    {
        return get_Ticks() == other.get_Ticks();
    }
        
    constexpr bool operator!=(DateTime other) const
    {
        return get_Ticks() != other.get_Ticks();
    }
        
    constexpr bool operator<(DateTime other) const
    {
        return get_Ticks() < other.get_Ticks();
    }
        
    constexpr bool operator<=(DateTime other) const
    {
        return get_Ticks() <= other.get_Ticks();
    }
        
    constexpr bool operator>(DateTime other) const
    {
        return get_Ticks() > other.get_Ticks();
    }
 
    constexpr bool operator>=(DateTime other) const
    {
        return get_Ticks() >= other.get_Ticks();
    }
 
    DateTime operator+(TimeSpan value) const
    {
        return Add(value);
    }
        
    DateTime operator-(TimeSpan value) const
    {
        return Subtract(value);
    }
        
    DateTime& operator+=(TimeSpan value)
    {
        return *this = Add(value);
    }
        
    DateTime& operator-=(TimeSpan value)
    {
        return *this = Subtract(value);
    }
 
    constexpr TimeSpan operator-(DateTime value) const
    {
        return Subtract(value);
    }
 
    static const TypeInfo& Type()
    {
        return *static_holder<ThisTypeInfo>();
    }
 
    constexpr bool IsNull() const { return false; }
    constexpr bool operator==(std::nullptr_t) const { return false; }
    constexpr bool operator!=(std::nullptr_t) const { return true; }
    constexpr bool operator<(std::nullptr_t) const { return false; }
    constexpr bool operator<=(std::nullptr_t) const { return false; }
    constexpr bool operator>(std::nullptr_t) const { return false; }
    constexpr bool operator>=(std::nullptr_t) const { return false; }
 
private:
    uint64_t m_data;
 
    static constexpr uint64_t TicksMask = 0x3FFFFFFFFFFFFFFF;
    static constexpr uint64_t FlagsMask = 0xC000000000000000;
 
    constexpr uint64_t Flags() const { return m_data & FlagsMask; }
    struct InternalConstructorTag {};
    static constexpr InternalConstructorTag InternalConstructor{};
    constexpr DateTime(uint64_t data, InternalConstructorTag) : m_data(data) {}
 
    struct ThisTypeInfo : TypeInfoPtr
    {
        ThisTypeInfo()
            : TypeInfoPtr(u"System::DateTime")
        {}
    };
 
#if defined(_DEBUG) && defined(_MSC_VER)
    struct NatvisHelpers
    {
        static constexpr unsigned DaysTo1901 = 693960;
        static constexpr unsigned DaysTo2100 = 766644;
        static constexpr unsigned DaysTo10000 = 3652058;
        static constexpr unsigned DaysPer4Years = 1461;
 
        struct Date { uint64_t ticks : 62; };
        struct Days { uint64_t ticks:62; };
        struct HoursMinutesSeconds { uint64_t ticks:62; };
        struct Fraction { uint64_t ticks:62; };
        struct TimeOfDay { uint64_t data; };
    };
#endif
};
 
constexpr bool operator==(std::nullptr_t, DateTime) { return false; }
constexpr bool operator!=(std::nullptr_t, DateTime) { return true; }
constexpr bool operator<(std::nullptr_t, DateTime) { return false; }
constexpr bool operator<=(std::nullptr_t, DateTime) { return false; }
constexpr bool operator>(std::nullptr_t, DateTime) { return false; }
constexpr bool operator>=(std::nullptr_t, DateTime) { return false; }
 
template<> struct IsBoxable<DateTime> : std::true_type {};
 
ASPOSECPP_SHARED_API void PrintTo(DateTime value, std::ostream* stream);
 
inline std::ostream& operator<<(std::ostream& stream, DateTime date_time)
{
    stream << date_time.ToString();
    return stream;
}
 
inline std::wostream& operator<<(std::wostream& stream, DateTime date_time)
{
    stream << date_time.ToString();
    return stream;
}
 
} // namespace System
 
namespace std {
    template <>
    class hash<System::DateTime>
    {
    public:
        using argument_type = System::DateTime;
        using result_type = std::size_t;
        result_type operator()(const argument_type& value) const
        {
            return static_cast<result_type>(value.GetHashCode());
        }
    };
}