Program Listing for File Date.h

↰ Return to documentation for file (axr.sdk/Date.h)

#pragma once

#include <cpprest/details/basic_types.h>

namespace axr {
namespace sdk {

class datetime
{
public:
    typedef uint64_t interval_type;

    enum date_format
    {
        RFC_1123,
        ISO_8601
    };

    static _ASYNCRTIMP datetime __cdecl utc_now();

    enum : interval_type
    {
        utc_timestamp_invalid = static_cast<interval_type>(-1)
    };

    static interval_type utc_timestamp()
    {
        const auto seconds = utc_now().to_interval() / _secondTicks;
        if (seconds >= 11644473600LL)
        {
            return seconds - 11644473600LL;
        }
        else
        {
            return utc_timestamp_invalid;
        }
    }

    datetime() : m_interval(0) { }

    static _ASYNCRTIMP datetime __cdecl from_string(const utility::string_t& timestring, date_format format = RFC_1123);

    static _ASYNCRTIMP datetime __cdecl from_string_maximum_error(const utility::string_t& timestring,
        date_format format = RFC_1123);

    _ASYNCRTIMP utility::string_t to_string(date_format format = RFC_1123) const;

    interval_type to_interval() const { return m_interval; }

    static datetime from_interval(interval_type interval) { return datetime(interval); }

    datetime operator-(interval_type value) const { return datetime(m_interval - value); }

    datetime operator+(interval_type value) const { return datetime(m_interval + value); }

    bool operator==(datetime dt) const { return m_interval == dt.m_interval; }

    bool operator!=(const datetime& dt) const { return !(*this == dt); }

    bool operator>(const datetime& dt) const { return this->m_interval > dt.m_interval; }

    bool operator<(const datetime& dt) const { return this->m_interval < dt.m_interval; }

    bool operator>=(const datetime& dt) const { return this->m_interval >= dt.m_interval; }

    bool operator<=(const datetime& dt) const { return this->m_interval <= dt.m_interval; }

    static interval_type from_milliseconds(unsigned int milliseconds) { return milliseconds * _msTicks; }

    static interval_type from_seconds(unsigned int seconds) { return seconds * _secondTicks; }

    static interval_type from_minutes(unsigned int minutes) { return minutes * _minuteTicks; }

    static interval_type from_hours(unsigned int hours) { return hours * _hourTicks; }

    static interval_type from_days(unsigned int days) { return days * _dayTicks; }

    bool is_initialized() const { return m_interval != 0; }

    static datetime maximum() { return datetime(static_cast<interval_type>(-1)); }

private:
    friend int operator-(datetime t1, datetime t2);

    static const interval_type _msTicks = static_cast<interval_type>(10000);
    static const interval_type _secondTicks = 1000 * _msTicks;
    static const interval_type _minuteTicks = 60 * _secondTicks;
    static const interval_type _hourTicks = 60 * 60 * _secondTicks;
    static const interval_type _dayTicks = 24 * 60 * 60 * _secondTicks;

    // Private constructor. Use static methods to create an instance.
    datetime(interval_type interval) : m_interval(interval) { }

    // Storing as hundreds of nanoseconds 10e-7, i.e. 1 here equals 100ns.
    interval_type m_interval;
};

inline int operator-(datetime t1, datetime t2)
{
    auto diff = (t1.m_interval - t2.m_interval);

    // Round it down to seconds
    diff /= 10 * 1000 * 1000;

    return static_cast<int>(diff);
}

} // namespace sdk
} // namespace axr