timespan.h

 
#pragma once
 
#include <system/string.h>
#include <system/boxable_traits.h>
#include <system/iformatprovider.h>
#include <system/globalization/time_span_styles.h>
#include <functional>
 
namespace System {
 
namespace Globalization {
    class CultureInfo;
    class DateTimeFormatInfo;
}
 
class ASPOSECPP_SHARED_CLASS TimeSpan final
{
public:
    static ASPOSECPP_SHARED_API const TimeSpan Zero;
    static ASPOSECPP_SHARED_API const TimeSpan MaxValue;
    static ASPOSECPP_SHARED_API const TimeSpan MinValue;
 
    static constexpr int64_t TicksPerDay = 864000000000ULL;
    static constexpr int64_t TicksPerHour = 36000000000ULL;
    static constexpr int64_t TicksPerMillisecond = 10000ULL;
    static constexpr int64_t TicksPerMinute = 600000000ULL;
    static constexpr int64_t TicksPerSecond = 10000000ULL;
 
    constexpr TimeSpan() : m_ticks(0) {}
 
    // dotnetTicks - .NET ticks as 100ns since 0001.01.01-00:00:00
    explicit constexpr TimeSpan(int64_t ticks) : m_ticks(ticks) {}
 
    ASPOSECPP_SHARED_API TimeSpan(int hours, int minutes, int seconds);
 
    ASPOSECPP_SHARED_API TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds = 0);
 
    constexpr TimeSpan(const TimeSpan&) = default;
 
    constexpr TimeSpan& operator=(const TimeSpan&) = default;
 
    static constexpr TimeSpan FromTicks(int64_t ticks)
    {
        return TimeSpan(ticks);
    }
 
    static TimeSpan FromMilliseconds(double value)
    {
        return Interval(value, 1);
    }
 
    static TimeSpan FromSeconds(double value)
    {
        constexpr int MillisecondsPerSecond = 1000;
        return Interval(value, MillisecondsPerSecond);
    }
 
    static TimeSpan FromMinutes(double value)
    {
        constexpr int MillisecondsPerMinute = 60 * 1000;
        return Interval(value, MillisecondsPerMinute);
    }
 
    static TimeSpan FromHours(double value)
    {
        constexpr int MillisecondsPerHour = 60 * 60 * 1000;
        return Interval(value, MillisecondsPerHour);
    }
 
    static TimeSpan FromDays(double value)
    {
        constexpr int MillisecondsPerDay = 24 * 60 * 60 * 1000;
        return Interval(value, MillisecondsPerDay);
    }
 
    static constexpr int Compare(TimeSpan t1, TimeSpan t2)
    {
        if (t1.m_ticks > t2.m_ticks) return 1;
        if (t1.m_ticks < t2.m_ticks) return -1;
        return 0;
    }
 
    constexpr int CompareTo(TimeSpan value) const
    {
        return Compare(*this, value);
    }
 
    ASPOSECPP_SHARED_API int CompareTo(const SharedPtr<Object>& obj) const;
 
    constexpr bool Equals(TimeSpan value) const
    {
        return m_ticks == value.m_ticks;
    }
 
    ASPOSECPP_SHARED_API bool Equals(const SharedPtr<Object>& obj) const;
 
    static constexpr bool Equals(TimeSpan a, TimeSpan b)
    {
        return a.m_ticks == b.m_ticks;
    }
 
    ASPOSECPP_SHARED_API int GetHashCode() const;
 
    constexpr int get_Days() const
    {
        return static_cast<int>(m_ticks / TicksPerDay);
    }
 
    constexpr int get_Hours() const
    {
        return static_cast<int>((m_ticks / TicksPerHour) % 24);
    }
 
    constexpr int get_Minutes() const
    {
        return static_cast<int>((m_ticks / TicksPerMinute) % 60);
    }
 
    constexpr int get_Seconds() const
    {
        return static_cast<int>((m_ticks / TicksPerSecond) % 60);
    }
 
    constexpr int get_Milliseconds() const
    {
        return static_cast<int>((m_ticks / TicksPerMillisecond) % 1000);
    }
 
    constexpr int64_t get_Ticks() const
    {
        return m_ticks;
    }
 
    constexpr double get_TotalDays() const
    {
        return static_cast<double>(m_ticks) / TicksPerDay;
    }
 
    constexpr double get_TotalHours() const
    {
        return static_cast<double>(m_ticks) / TicksPerHour;
    }
 
    constexpr double get_TotalMinutes() const
    {
        return static_cast<double>(m_ticks) / TicksPerMinute;
    }
 
    constexpr double get_TotalSeconds() const
    {
        return static_cast<double>(m_ticks) / TicksPerSecond;
    }
 
    ASPOSECPP_SHARED_API double get_TotalMilliseconds() const;
 
    ASPOSECPP_SHARED_API TimeSpan Add(TimeSpan value) const;
 
    ASPOSECPP_SHARED_API TimeSpan Subtract(TimeSpan value) const;
 
    ASPOSECPP_SHARED_API TimeSpan Negate() const;
 
    ASPOSECPP_SHARED_API TimeSpan Duration() const;
 
    ASPOSECPP_SHARED_API String ToString() const;
 
    ASPOSECPP_SHARED_API String ToString(const String& format) const;
 
    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); }
 
    static ASPOSECPP_SHARED_API TimeSpan Parse(const String& input);
 
    static ASPOSECPP_SHARED_API TimeSpan Parse(const String& input, const SharedPtr<IFormatProvider>& provider);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API TimeSpan Parse(const String& input, const SharedPtr<Globalization::CultureInfo>& culture);
    static ASPOSECPP_SHARED_API TimeSpan Parse(const String& input, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi);
    static TimeSpan Parse(const String& input, std::nullptr_t) { return Parse(input); }
 
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<IFormatProvider>& provider, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const ArrayPtr<String>& formats, std::nullptr_t, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
 
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const String& format, const SharedPtr<IFormatProvider>& provider, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const String& format, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
    static ASPOSECPP_SHARED_API TimeSpan ParseExact(const String& input, const String& format, std::nullptr_t, Globalization::TimeSpanStyles styles = Globalization::TimeSpanStyles::None);
 
    static ASPOSECPP_SHARED_API bool TryParse(const String& input, TimeSpan& result);
 
    static ASPOSECPP_SHARED_API bool TryParse(const String& input, const SharedPtr<IFormatProvider>& provider, TimeSpan& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParse(const String& input, const SharedPtr<Globalization::CultureInfo>& culture, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParse(const String& input, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParse(const String& input, std::nullptr_t, TimeSpan& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<IFormatProvider>& provider, TimeSpan& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::CultureInfo>& culture, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, std::nullptr_t, TimeSpan& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<IFormatProvider>& provider, Globalization::TimeSpanStyles styles, TimeSpan& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::TimeSpanStyles styles, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::TimeSpanStyles styles, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, std::nullptr_t, Globalization::TimeSpanStyles styles, TimeSpan& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<IFormatProvider>& provider, Globalization::TimeSpanStyles styles, TimeSpan& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::CultureInfo>& culture, Globalization::TimeSpanStyles styles, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, Globalization::TimeSpanStyles styles, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const ArrayPtr<String>& formats, std::nullptr_t, Globalization::TimeSpanStyles styles, TimeSpan& result);
 
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<IFormatProvider>& provider, TimeSpan& result);
    // Optimized function overloads
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<Globalization::CultureInfo>& culture, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, const SharedPtr<Globalization::DateTimeFormatInfo>& dtfi, TimeSpan& result);
    static ASPOSECPP_SHARED_API bool TryParseExact(const String& input, const String& format, std::nullptr_t, TimeSpan& result);
 
    TimeSpan operator+(TimeSpan value) const
    {
        return Add(value);
    }
 
    TimeSpan& operator+=(TimeSpan value)
    {
        return *this = Add(value);
    }
 
    TimeSpan operator-(TimeSpan value) const
    {
        return Subtract(value);
    }
 
    TimeSpan& operator-=(TimeSpan value)
    {
        return *this = Subtract(value);
    }
 
    TimeSpan operator-() const
    {
        return Negate();
    }
 
    TimeSpan operator+() const
    {
        return *this;
    }
 
    ASPOSECPP_SHARED_API TimeSpan operator/(double divisor) const;
 
    TimeSpan& operator/=(double divisor)
    {
        return *this = operator/(divisor);
    }
 
    constexpr double operator/(TimeSpan value) const
    {
        return m_ticks / static_cast<double>(value.m_ticks);
    }
 
    constexpr bool operator==(TimeSpan value) const
    {
        return m_ticks == value.m_ticks;
    }
 
    constexpr bool operator!=(TimeSpan value) const
    {
        return m_ticks != value.m_ticks;
    }
 
    constexpr bool operator<(TimeSpan value) const
    {
        return m_ticks < value.m_ticks;
    }
 
    constexpr bool operator<=(TimeSpan value) const
    {
        return m_ticks <= value.m_ticks;
    }
 
    constexpr bool operator>(TimeSpan value) const
    {
        return m_ticks > value.m_ticks;
    }
    
    constexpr bool operator>=(TimeSpan value) const
    {
        return m_ticks >= value.m_ticks;
    }
 
    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:
    int64_t m_ticks;
 
    struct ThisTypeInfo : TypeInfoPtr
    {
        ThisTypeInfo()
            : TypeInfoPtr(u"System::TimeSpan")
        {}
    };
 
    static ASPOSECPP_SHARED_API TimeSpan Interval(double value, int scale);
 
#if defined(_DEBUG) && defined(_MSC_VER)
    struct NatvisHelpers
    {
        struct Days { int64_t ticks; };
        struct HoursMinutes { int64_t ticks; };
        struct HoursMinutesSeconds { int64_t ticks; };
        struct Fraction { int64_t ticks; };
    };
#endif
 
}; // class TimeSpan
 
constexpr bool operator==(std::nullptr_t, TimeSpan) { return false; }
constexpr bool operator!=(std::nullptr_t, TimeSpan) { return true; }
constexpr bool operator<(std::nullptr_t, TimeSpan) { return false; }
constexpr bool operator<=(std::nullptr_t, TimeSpan) { return false; }
constexpr bool operator>(std::nullptr_t, TimeSpan) { return false; }
constexpr bool operator>=(std::nullptr_t, TimeSpan) { return false; }
 
template<> struct IsBoxable<TimeSpan> : std::true_type {};
 
ASPOSECPP_SHARED_API void PrintTo(TimeSpan value, std::ostream* stream);
 
inline std::ostream& operator<<(std::ostream& stream, TimeSpan time_span)
{
    stream << time_span.ToString();
    return stream;
}
 
inline std::wostream& operator<<(std::wostream& stream, TimeSpan time_span)
{
    stream << time_span.ToString();
    return stream;
}
 
} // namespace System
 
namespace std {
    template <>
    class hash<System::TimeSpan>
    {
    public:
        using argument_type = System::TimeSpan;
        using result_type = std::size_t;
 
        result_type operator()(argument_type value) const
        {
            return static_cast<result_type>(value.GetHashCode());
        }
    };
}