DateTime.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Misc/Timespan.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/TypeHash.h"
 
class FArchive;
class FOutputDevice;
class UObject;
 
 
enum class EDayOfWeek
{
    Monday = 0,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
};
 
 
enum class EMonthOfYear
{
    January = 1,
    February,
    March,
    April,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December
};
 
 
struct FDateTime
{
public:
 
    FDateTime()
        : Ticks(0)
    { }
 
    FDateTime(int64 InTicks)
        : Ticks(InTicks)
    { }
 
    CORE_API FDateTime(int32 Year, int32 Month, int32 Day, int32 Hour = 0, int32 Minute = 0, int32 Second = 0, int32 Millisecond = 0);
 
public:
 
    FDateTime operator+(const FTimespan& Other) const
    {
        return FDateTime(Ticks + Other.GetTicks());
    }
 
    FDateTime& operator+=(const FTimespan& Other)
    {
        Ticks += Other.GetTicks();
 
        return *this;
    }
 
    UE_DEPRECATED(5.1, "Adding dates doesn't make sense. Please use FDateTime + FTimespan instead")
    FDateTime operator+(const FDateTime& Other)
    {
        return FDateTime(Ticks + Other.Ticks);
    }
 
    FTimespan operator-(const FDateTime& Other) const
    {
        return FTimespan(Ticks - Other.Ticks);
    }
 
    FDateTime operator-(const FTimespan& Other) const
    {
        return FDateTime(Ticks - Other.GetTicks());
    }
 
    FDateTime& operator-=(const FTimespan& Other)
    {
        Ticks -= Other.GetTicks();
 
        return *this;
    }
 
    bool operator==(const FDateTime& Other) const
    {
        return (Ticks == Other.Ticks);
    }
 
    bool operator!=(const FDateTime& Other) const
    {
        return (Ticks != Other.Ticks);
    }
 
    bool operator>(const FDateTime& Other) const
    {
        return (Ticks > Other.Ticks);
    }
 
    bool operator>=(const FDateTime& Other) const
    {
        return (Ticks >= Other.Ticks);
    }
 
    bool operator<(const FDateTime& Other) const
    {
        return (Ticks < Other.Ticks);
    }
 
    bool operator<=(const FDateTime& Other) const
    {
        return (Ticks <= Other.Ticks);
    }
 
public:
 
    CORE_API bool ExportTextItem(FString& ValueStr, FDateTime const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
 
    FDateTime GetDate() const
    {
        return FDateTime(Ticks - (Ticks % ETimespan::TicksPerDay));
    }
 
    CORE_API void GetDate(int32& OutYear, int32& OutMonth, int32& OutDay) const;
 
    CORE_API int32 GetDay() const;
 
    CORE_API EDayOfWeek GetDayOfWeek() const;
 
    CORE_API int32 GetDayOfYear() const;
 
    int32 GetHour() const
    {
        return (int32)((Ticks / ETimespan::TicksPerHour) % 24);
    }
 
    CORE_API int32 GetHour12() const;
 
    double GetJulianDay() const
    {
        return 1721425.5 + double(Ticks / ETimespan::TicksPerDay) + GetTimeOfDay().GetTotalDays();
    }
 
    double GetModifiedJulianDay() const
    {
        return (GetJulianDay() - 2400000.5);
    }
 
    int32 GetMillisecond() const
    {
        return (int32)((Ticks / ETimespan::TicksPerMillisecond) % 1000);
    }
 
    int32 GetMinute() const
    {
        return (int32)((Ticks / ETimespan::TicksPerMinute) % 60);
    }
 
    CORE_API int32 GetMonth() const;
 
    EMonthOfYear GetMonthOfYear() const
    {
        return static_cast<EMonthOfYear>(GetMonth());
    }
 
    int32 GetSecond() const
    {
        return (int32)((Ticks / ETimespan::TicksPerSecond) % 60);
    }
 
    int64 GetTicks() const
    {
        return Ticks;
    }
 
    FTimespan GetTimeOfDay() const
    {
        return FTimespan(Ticks % ETimespan::TicksPerDay);
    }
 
    CORE_API int32 GetYear() const;
 
    CORE_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
 
    bool IsAfternoon() const
    {
        return (GetHour() >= 12);
    }
 
    bool IsMorning() const
    {
        return (GetHour() < 12);
    }
 
    CORE_API bool Serialize(FArchive& Ar);
 
    CORE_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    CORE_API FString ToHttpDate() const;
 
    CORE_API FString ToIso8601() const;
 
    CORE_API FString ToString() const;
 
    CORE_API FString ToString(const TCHAR* Format) const;
    CORE_API void ToString(const TCHAR* Format, FStringBuilderBase& Result) const;
 
    CORE_API FString ToFormattedString(const TCHAR* Format) const;
 
    int64 ToUnixTimestamp() const
    {
        return (Ticks - FDateTime(1970, 1, 1).Ticks) / ETimespan::TicksPerSecond;
    }
 
    double ToUnixTimestampDecimal() const
    {
        return double(Ticks - FDateTime(1970, 1, 1).Ticks) / ETimespan::TicksPerSecond;
    }
 
public:
 
    static CORE_API int32 DaysInMonth(int32 Year, int32 Month);
 
    static CORE_API int32 DaysInYear(int32 Year);
 
    static FDateTime FromJulianDay(double JulianDay)
    {
        return FDateTime((int64)((JulianDay - 1721425.5) * ETimespan::TicksPerDay));
    }
 
    static FDateTime FromUnixTimestamp(int64 UnixTime)
    {
        return FDateTime(1970, 1, 1) + FTimespan(UnixTime * ETimespan::TicksPerSecond);
    }
 
    static FDateTime FromUnixTimestampDecimal(double UnixTime)
    {
        return FDateTime(1970, 1, 1) + FTimespan(int64(UnixTime * ETimespan::TicksPerSecond));
    }
 
    static CORE_API bool IsLeapYear(int32 Year);
 
    static FDateTime MaxValue()
    {
        return FDateTime(3652059 * ETimespan::TicksPerDay - 1);
    }
 
    static FDateTime MinValue()
    {
        return FDateTime(0);
    }
 
    static CORE_API FDateTime Now();
 
    static CORE_API bool Parse(const FString& DateTimeString, FDateTime& OutDateTime);
 
    static CORE_API bool ParseHttpDate(const FString& HttpDate, FDateTime& OutDateTime);
 
    static CORE_API bool ParseIso8601(const TCHAR* DateTimeString, FDateTime& OutDateTime);
 
    static FDateTime Today()
    {
        return Now().GetDate();
    }
 
    static CORE_API FDateTime UtcNow();
 
    static CORE_API bool Validate(int32 Year, int32 Month, int32 Day, int32 Hour, int32 Minute, int32 Second, int32 Millisecond);
 
public:
 
    friend FArchive& operator<<(FArchive& Ar, FDateTime& DateTime)
    {
        return Ar << DateTime.Ticks;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FDateTime& DateTime)
    {
        return Slot << DateTime.Ticks;
    }
 
    friend uint32 GetTypeHash(const FDateTime& DateTime)
    {
        return GetTypeHash(DateTime.Ticks);
    }
 
protected:
 
    static const int32 DaysPerMonth[];
 
    static const int32 DaysToMonth[];
 
    static const TCHAR* ShortDayNames[];
    static const TCHAR* LongDayNames[];
 
    static const TCHAR* ShortMonthNames[];
    static const TCHAR* LongMonthNames[];
 
private:
    friend struct Z_Construct_UScriptStruct_FDateTime_Statics;
 
private:
 
    int64 Ticks;
};