Timespan.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/Interval.h"
#include "Math/UnrealMathUtility.h"
#include "Misc/AssertionMacros.h"
 
class FArchive;
class FOutputDevice;
class FString;
class UObject;
template <typename ElementType> struct TIntervalTraits;
 
 
namespace ETimespan
{
    inline constexpr int64 MaxTicks = 9223372036854775807;
 
    inline constexpr int64 MinTicks = -9223372036854775807 - 1;
 
    inline constexpr int64 NanosecondsPerTick = 100;
 
    inline constexpr int64 TicksPerDay = 864000000000;
 
    inline constexpr int64 TicksPerHour = 36000000000;
 
    inline constexpr int64 TicksPerMicrosecond = 10;
 
    inline constexpr int64 TicksPerMillisecond = 10000;
 
    inline constexpr int64 TicksPerMinute = 600000000;
 
    inline constexpr int64 TicksPerSecond = 10000000;
 
    inline constexpr int64 TicksPerWeek = 6048000000000;
 
    inline constexpr int64 TicksPerYear = 365 * TicksPerDay;
}
 
 
struct FTimespan
{
public:
 
    FTimespan()
        : Ticks(0)
    { }
 
    FTimespan(int64 InTicks)
        : Ticks(InTicks)
    {
        check((InTicks >= ETimespan::MinTicks) && (InTicks <= ETimespan::MaxTicks));
    }
 
    FTimespan(int32 Hours, int32 Minutes, int32 Seconds)
    {
        Assign(0, Hours, Minutes, Seconds, 0);
    }
 
    FTimespan(int32 Days, int32 Hours, int32 Minutes, int32 Seconds)
    {
        Assign(Days, Hours, Minutes, Seconds, 0);
    }
 
    FTimespan(int32 Days, int32 Hours, int32 Minutes, int32 Seconds, int32 FractionNano)
    {
        Assign(Days, Hours, Minutes, Seconds, FractionNano);
    }
 
public:
 
    FTimespan operator+(const FTimespan& Other) const
    {
        return FTimespan(Ticks + Other.Ticks);
    }
 
    FTimespan& operator+=(const FTimespan& Other)
    {
        Ticks += Other.Ticks;
        return *this;
    }
 
    FTimespan operator-() const
    {
        return FTimespan(-Ticks);
    }
 
    FTimespan operator-(const FTimespan& Other) const
    {
        return FTimespan(Ticks - Other.Ticks);
    }
 
    FTimespan& operator-=(const FTimespan& Other)
    {
        Ticks -= Other.Ticks;
        return *this;
    }
 
    FTimespan operator*(double Scalar) const
    {
        return FTimespan((int64)((double)Ticks * Scalar));
    }
 
    FTimespan& operator*=(double Scalar)
    {
        Ticks = (int64)((double)Ticks * Scalar);
        return *this;
    }
 
    FTimespan operator/(double Scalar) const
    {
        return FTimespan((int64)((double)Ticks / Scalar));
    }
 
    FTimespan& operator/=(double Scalar)
    {
        Ticks = (int64)((double)Ticks / Scalar);
        return *this;
    }
 
    FTimespan operator%(const FTimespan& Other) const
    {
        return FTimespan(Ticks % Other.Ticks);
    }
 
    FTimespan& operator%=(const FTimespan& Other)
    {
        Ticks = Ticks % Other.Ticks;
        return *this;
    }
 
    bool operator==(const FTimespan& Other) const
    {
        return (Ticks == Other.Ticks);
    }
 
    bool operator!=(const FTimespan& Other) const
    {
        return (Ticks != Other.Ticks);
    }
 
    bool operator>(const FTimespan& Other) const
    {
        return (Ticks > Other.Ticks);
    }
 
    bool operator>=(const FTimespan& Other) const
    {
        return (Ticks >= Other.Ticks);
    }
 
    bool operator<(const FTimespan& Other) const
    {
        return (Ticks < Other.Ticks);
    }
 
    bool operator<=(const FTimespan& Other) const
    {
        return (Ticks <= Other.Ticks);
    }
 
public:
 
    CORE_API bool ExportTextItem(FString& ValueStr, FTimespan const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
 
    int32 GetDays() const
    {
        return (int32)(Ticks / ETimespan::TicksPerDay);
    }
 
    FTimespan GetDuration()
    {
        return FTimespan(Ticks >= 0 ? Ticks : -Ticks);
    }
 
    int32 GetFractionMicro() const
    {
        return (int32)((Ticks % ETimespan::TicksPerSecond) / ETimespan::TicksPerMicrosecond);
    }
 
    int32 GetFractionMilli() const
    {
        return (int32)((Ticks % ETimespan::TicksPerSecond) / ETimespan::TicksPerMillisecond);
    }
 
    int32 GetFractionNano() const
    {
        return (int32)((Ticks % ETimespan::TicksPerSecond) * ETimespan::NanosecondsPerTick);
    }
 
    int32 GetFractionTicks() const
    {
        return (int32)(Ticks % ETimespan::TicksPerSecond);
    }
 
    int32 GetHours() const
    {
        return (int32)((Ticks / ETimespan::TicksPerHour) % 24);
    }
 
    int32 GetMinutes() const
    {
        return (int32)((Ticks / ETimespan::TicksPerMinute) % 60);
    }
 
    int32 GetSeconds() const
    {
        return (int32)((Ticks / ETimespan::TicksPerSecond) % 60);
    }
 
    int64 GetTicks() const
    {
        return Ticks;
    }
 
    double GetTotalDays() const
    {
        return ((double)Ticks / ETimespan::TicksPerDay);
    }
 
    double GetTotalHours() const
    {
        return ((double)Ticks / ETimespan::TicksPerHour);
    }
 
    double GetTotalMicroseconds() const
    {
        return ((double)Ticks / ETimespan::TicksPerMicrosecond);
    }
 
    double GetTotalMilliseconds() const
    {
        return ((double)Ticks / ETimespan::TicksPerMillisecond);
    }
 
    double GetTotalMinutes() const
    {
        return ((double)Ticks / ETimespan::TicksPerMinute);
    }
 
    double GetTotalSeconds() const
    {
        return ((double)Ticks / ETimespan::TicksPerSecond);
    }
 
    CORE_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
 
    bool IsZero() const
    {
        return (Ticks == 0LL);
    }
 
    CORE_API bool Serialize(FArchive& Ar);
 
    CORE_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    CORE_API FString ToString() const;
 
    CORE_API FString ToString(const TCHAR* Format) const;
 
public:
 
    static FTimespan FromDays(double Days)
    {
        return FTimespan((int64)FMath::FloorToDouble(Days * ETimespan::TicksPerDay + 0.5));
    }
 
    static FTimespan FromHours(double Hours)
    {
        return FTimespan((int64)FMath::FloorToDouble(Hours * ETimespan::TicksPerHour + 0.5));
    }
 
    static FTimespan FromMicroseconds(double Microseconds)
    {
        return FTimespan((int64)FMath::FloorToDouble(Microseconds * ETimespan::TicksPerMicrosecond + 0.5));
    }
 
    static FTimespan FromMilliseconds(double Milliseconds)
    {
        return FTimespan((int64)FMath::FloorToDouble(Milliseconds * ETimespan::TicksPerMillisecond + 0.5));
    }
 
    static FTimespan FromMinutes(double Minutes)
    {
        return FTimespan((int64)FMath::FloorToDouble(Minutes * ETimespan::TicksPerMinute + 0.5));
    }
 
    static FTimespan FromSeconds(double Seconds)
    {
        return FTimespan((int64)FMath::FloorToDouble(Seconds * ETimespan::TicksPerSecond + 0.5));
    }
 
    static FTimespan MaxValue()
    {
        return FTimespan(ETimespan::MaxTicks);
    }
 
    static FTimespan MinValue()
    {
        return FTimespan(ETimespan::MinTicks);
    }
 
    static CORE_API bool Parse(const FString& TimespanString, FTimespan& OutTimespan);
 
    static double Ratio(FTimespan Dividend, FTimespan Divisor)
    {
        if (Divisor == FTimespan::Zero())
        {
            return 0.0;
        }
 
        return (double)Dividend.GetTicks() / (double)Divisor.GetTicks();
    }
 
    static FTimespan Zero()
    {
        return FTimespan(0);
    }
 
public:
 
    friend class UObject;
 
    friend CORE_API FArchive& operator<<(FArchive& Ar, FTimespan& Timespan);
 
    friend CORE_API uint32 GetTypeHash(const FTimespan& Timespan);
 
protected:
 
    void CORE_API Assign(int32 Days, int32 Hours, int32 Minutes, int32 Seconds, int32 FractionNano);
 
private:
    friend struct Z_Construct_UScriptStruct_FTimespan_Statics;
 
private:
 
    int64 Ticks;
};
 
template <>
struct TIntervalTraits<FTimespan>
{
    static FTimespan Max()
    {
        return FTimespan::MaxValue();
    }
 
    static FTimespan Lowest()
    {
        return FTimespan::MinValue();
    }
};
 
inline FTimespan operator*(float Scalar, const FTimespan& Timespan)
{
    return Timespan.operator*(Scalar);
}