Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.datetime.systime

License:
Boost License 1.0.
Authors:
Jonathan M Davis

Source std/datetime/systime.d

class `Clock`;
  Effectively a namespace to make it clear that the methods it contains are getting the time from the system clock. It cannot be instantiated.
  @safe SysTime `currTime`(ClockType clockType = ClockType.normal)(immutable TimeZone `tz` = LocalTime());
    Returns the current time in the given time zone.
    Parameters:

    clockType | The core.time.ClockType indicates which system clock to use to get the current time. Very few programs need to use anything other than the default.
    TimeZone `tz` | The time zone for the SysTime that's returned.

    Throws:
    std.datetime.date.DateTimeException if it fails to get the time.
  @property @trusted long `currStdTime`(ClockType clockType = ClockType.normal)();
    Returns the number of hnsecs since midnight, January 1st, 1 A.D. for the current time.
    Parameters:

    clockType | The core.time.ClockType indicates which system clock to use to get the current time. Very few programs need to use anything other than the default.

    Throws:
    std.datetime.date.DateTimeException if it fails to get the time.
struct `SysTime`;
  `SysTime` is the type used to get the current time from the system or doing anything that involves time zones. Unlike std.datetime.date.DateTime, the time zone is an integral part of `SysTime` (though for local time applications, time zones can be ignored and it will work, since it defaults to using the local time zone). It holds its internal time in std time (hnsecs since midnight, January 1st, 1 A.D. UTC), so it interfaces well with the system time. However, that means that, unlike std.datetime.date.DateTime, it is not optimized for calendar-based operations, and getting individual units from it such as years or days is going to involve conversions and be less efficient.
  For calendar-based operations that don't care about time zones, then std.datetime.date.DateTime would be the type to use. For system time, use `SysTime`.
  Clock.currTime will return the current time as a `SysTime`. To convert a `SysTime` to a std.datetime.date.Date or std.datetime.date.DateTime, simply cast it. To convert a std.datetime.date.Date or std.datetime.date.DateTime to a `SysTime`, use `SysTime`'s constructor, and pass in the ntended time zone with it (or don't pass in a std.datetime.timezone.TimeZone, and the local time zone will be used). Be aware, however, that converting from a std.datetime.date.DateTime to a `SysTime` will not necessarily be 100% accurate due to DST (one hour of the year doesn't exist and another occurs twice). To not risk any conversion errors, keep times as `SysTime`s. Aside from DST though, there shouldn't be any conversion problems.
  For using time zones other than local time or UTC, use std.datetime.timezone.PosixTimeZone on Posix systems (or on Windows, if providing the TZ Database files), and use std.datetime.timezone.WindowsTimeZone on Windows systems. The time in `SysTime` is kept internally in hnsecs from midnight, January 1st, 1 A.D. UTC. Conversion error cannot happen when changing the time zone of a `SysTime`. std.datetime.timezone.LocalTime is the std.datetime.timezone.TimeZone class which represents the local time, and UTC is the std.datetime.timezone.TimeZone class which represents UTC. `SysTime` uses std.datetime.timezone.LocalTime if no std.datetime.timezone.TimeZone is provided. For more details on time zones, see the documentation for std.datetime.timezone.TimeZone, std.datetime.timezone.PosixTimeZone, and std.datetime.timezone.WindowsTimeZone.
  `SysTime`'s range is from approximately 29,000 B.C. to approximately 29,000 A.D.
  nothrow @safe this(in DateTime `dateTime`, immutable TimeZone `tz` = null);
    Parameters:

    DateTime `dateTime` | The std.datetime.date.DateTime to use to set this SysTime's internal std time. As std.datetime.date.DateTime has no concept of time zone, `tz` is used as its time zone.
    TimeZone `tz` | The std.datetime.timezone.TimeZone to use for this SysTime. If `null`, std.datetime.timezone.LocalTime will be used. The given std.datetime.date.DateTime is assumed to be in the given time zone.

  @safe this(in DateTime `dateTime`, in Duration `fracSecs`, immutable TimeZone `tz` = null);
    Parameters:

    DateTime `dateTime` | The std.datetime.date.DateTime to use to set this SysTime's internal std time. As std.datetime.date.DateTime has no concept of time zone, `tz` is used as its time zone.
    Duration `fracSecs` | The fractional seconds portion of the time.
    TimeZone `tz` | The std.datetime.timezone.TimeZone to use for this SysTime. If `null`, std.datetime.timezone.LocalTime will be used. The given std.datetime.date.DateTime is assumed to be in the given time zone.

    Throws:
    std.datetime.date.DateTimeException if `fracSecs` is negative or if it's greater than or equal to one second.
  nothrow @safe this(in Date `date`, immutable TimeZone `tz` = null);
    Parameters:

    Date `date` | The date.html#.Date">std.datetime.`date`.Date to use to set this SysTime's internal std time. As date.html#.Date">std.datetime.`date`.Date has no concept of time zone, `tz` is used as its time zone.
    TimeZone `tz` | The std.datetime.timezone.TimeZone to use for this SysTime. If `null`, std.datetime.timezone.LocalTime will be used. The given date.html#.Date">std.datetime.`date`.Date is assumed to be in the given time zone.

  pure nothrow @safe this(long `stdTime`, immutable TimeZone `tz` = null);

    Note Whereas the other constructors take in the given date/time, assume that it's in the given time zone, and convert it to hnsecs in UTC since midnight, January 1st, 1 A.D. UTC - i.e. std time - this constructor takes a std time, which is specifically already in UTC, so no conversion takes place. Of course, the various getter properties and functions will use the given time zone's conversion function to convert the results to that time zone, but no conversion of the arguments to this constructor takes place.

    Parameters:

    long `stdTime` | The number of hnsecs since midnight, January 1st, 1 A.D. UTC.
    TimeZone `tz` | The std.datetime.timezone.TimeZone to use for this SysTime. If `null`, std.datetime.timezone.LocalTime will be used.

  pure nothrow ref return @safe SysTime `opAssign`(ref const SysTime `rhs`);
    Parameters:

    SysTime `rhs` | The SysTime to assign to this one.

  pure nothrow ref return scope @safe SysTime `opAssign`(SysTime `rhs`);
    Parameters:

    SysTime `rhs` | The SysTime to assign to this one.

  const pure nothrow @safe bool `opEquals`(const SysTime `rhs`);
  const pure nothrow @safe bool `opEquals`(ref const SysTime `rhs`);
    Checks for equality between this SysTime and the given SysTime.
    Note that the time zone is ignored. Only the internal std times (which are in UTC) are compared.
  const pure nothrow @safe int `opCmp`(in SysTime `rhs`);
    Compares this SysTime with the given SysTime.
    Time zone is irrelevant when comparing SysTimes.
    Returns:

    this < `rhs` | < 0
    this == `rhs` | 0
    this > `rhs` | > 0

  const pure nothrow @nogc @safe size_t `toHash`();
    Returns:
    A hash of the SysTime
  const nothrow @property @safe short `year`();
    Year of the Gregorian Calendar. Positive numbers are A.D. Non-positive are B.C.
  @property @safe void `year`(int `year`);
    Year of the Gregorian Calendar. Positive numbers are A.D. Non-positive are B.C.
    Parameters:

    int `year` | The `year` to set this SysTime's `year` to.

    Throws:
    std.datetime.date.DateTimeException if the new `year` is not a leap `year` and the resulting date would be on February 29th.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1999, 7, 6, 9, 7, 5)).year); // 1999
        writeln(SysTime(DateTime(2010, 10, 4, 0, 0, 30)).year); // 2010
        writeln(SysTime(DateTime(-7, 4, 5, 7, 45, 2)).year); // -7

  const @property @safe ushort `yearBC`();
    Year B.C. of the Gregorian Calendar counting year 0 as 1 B.C.
    Throws:
    std.datetime.date.DateTimeException if isAD is `true`.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(0, 1, 1, 12, 30, 33)).yearBC); // 1
        writeln(SysTime(DateTime(-1, 1, 1, 10, 7, 2)).yearBC); // 2
        writeln(SysTime(DateTime(-100, 1, 1, 4, 59, 0)).yearBC); // 101

  @property @safe void `yearBC`(int `year`);
    Year B.C. of the Gregorian Calendar counting `year` 0 as 1 B.C.
    Parameters:

    int `year` | The `year` B.C. to set this SysTime's `year` to.

    Throws:
    std.datetime.date.DateTimeException if a non-positive value is given.
  const nothrow @property @safe Month `month`();
    Month of a Gregorian Year.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1999, 7, 6, 9, 7, 5)).month); // 7
        writeln(SysTime(DateTime(2010, 10, 4, 0, 0, 30)).month); // 10
        writeln(SysTime(DateTime(-7, 4, 5, 7, 45, 2)).month); // 4

  @property @safe void `month`(Month `month`);
    Month of a Gregorian Year.
    Parameters:

    Month `month` | The `month` to set this SysTime's `month` to.

    Throws:
    std.datetime.date.DateTimeException if the given `month` is not a valid `month`.
  const nothrow @property @safe ubyte `day`();
    Day of a Gregorian Month.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1999, 7, 6, 9, 7, 5)).day); // 6
        writeln(SysTime(DateTime(2010, 10, 4, 0, 0, 30)).day); // 4
        writeln(SysTime(DateTime(-7, 4, 5, 7, 45, 2)).day); // 5

  @property @safe void `day`(int `day`);
    Day of a Gregorian Month.
    Parameters:

    int `day` | The `day` of the month to set this SysTime's `day` to.

    Throws:
    std.datetime.date.DateTimeException if the given `day` is not a valid `day` of the current month.
  const nothrow @property @safe ubyte `hour`();
    Hours past midnight.
  @property @safe void `hour`(int `hour`);
    Hours past midnight.
    Parameters:

    int `hour` | The hours to set this SysTime's `hour` to.

    Throws:
    std.datetime.date.DateTimeException if the given `hour` are not a valid `hour` of the day.
  const nothrow @property @safe ubyte `minute`();
    Minutes past the current hour.
  @property @safe void `minute`(int `minute`);
    Minutes past the current hour.
    Parameters:

    int `minute` | The `minute` to set this SysTime's `minute` to.

    Throws:
    std.datetime.date.DateTimeException if the given `minute` are not a valid `minute` of an hour.
  const nothrow @property @safe ubyte `second`();
    Seconds past the current minute.
  @property @safe void `second`(int `second`);
    Seconds past the current minute.
    Parameters:

    int `second` | The `second` to set this SysTime's `second` to.

    Throws:
    std.datetime.date.DateTimeException if the given `second` are not a valid `second` of a minute.
  const nothrow @property @safe Duration `fracSecs`();
    Fractional seconds past the second (i.e. the portion of a SysTime which is less than a second).
    Examples:

        import core.time : msecs, usecs, hnsecs, nsecs;
        import std.datetime.date : DateTime;

        auto dt = DateTime(1982, 4, 1, 20, 59, 22);
        writeln(SysTime(dt, msecs(213)).fracSecs); // msecs(213)
        writeln(SysTime(dt, usecs(5202)).fracSecs); // usecs(5202)
        writeln(SysTime(dt, hnsecs(1234567)).fracSecs); // hnsecs(1234567)

        // SysTime and Duration both have a precision of hnsecs (100 ns),
        // so nsecs are going to be truncated.
        writeln(SysTime(dt, nsecs(123456789)).fracSecs); // nsecs(123456700)

  @property @safe void `fracSecs`(Duration `fracSecs`);
    Fractional seconds past the second (i.e. the portion of a SysTime which is less than a second).
    Parameters:

    Duration `fracSecs` | The duration to set this SysTime's fractional seconds to.

    Throws:
    std.datetime.date.DateTimeException if the given duration is negative or if it's greater than or equal to one second.
    Examples:

        import core.time : Duration, msecs, hnsecs, nsecs;
        import std.datetime.date : DateTime;

        auto st = SysTime(DateTime(1982, 4, 1, 20, 59, 22));
        writeln(st.fracSecs); // Duration.zero

        st.fracSecs = msecs(213);
        writeln(st.fracSecs); // msecs(213)

        st.fracSecs = hnsecs(1234567);
        writeln(st.fracSecs); // hnsecs(1234567)

        // SysTime has a precision of hnsecs (100 ns), so nsecs are
        // going to be truncated.
        st.fracSecs = nsecs(123456789);
        writeln(st.fracSecs); // hnsecs(1234567)

  const pure nothrow @property @safe long `stdTime`();
    The total hnsecs from midnight, January 1st, 1 A.D. UTC. This is the internal representation of SysTime.
  pure nothrow @property @safe void `stdTime`(long `stdTime`);
    The total hnsecs from midnight, January 1st, 1 A.D. UTC. This is the internal representation of SysTime.
    Parameters:

    long `stdTime` | The number of hnsecs since January 1st, 1 A.D. UTC.

  const pure nothrow @property @safe immutable(TimeZone) `timezone`();
    The current time zone of this SysTime. Its internal time is always kept in UTC, so there are no conversion issues between time zones due to DST. Functions which return all or part of the time - such as hours - adjust the time to this SysTime's time zone before returning.
  pure nothrow @property @safe void `timezone`(immutable TimeZone `timezone`);
    The current time zone of this SysTime. It's internal time is always kept in UTC, so there are no conversion issues between time zones due to DST. Functions which return all or part of the time - such as hours - adjust the time to this SysTime's time zone before returning.
    Parameters:

    TimeZone `timezone` | The std.datetime.timezone.TimeZone to set this SysTime's time zone to.

  const nothrow @property @safe bool `dstInEffect`();
    Returns whether DST is in effect for this SysTime.
  const nothrow @property @safe Duration `utcOffset`();
    Returns what the offset from UTC is for this SysTime. It includes the DST offset in effect at that time (if any).
  const pure nothrow @safe SysTime `toLocalTime`();
    Returns a SysTime with the same std time as this one, but with std.datetime.timezone.LocalTime as its time zone.
  const pure nothrow @safe SysTime `toUTC`();
    Returns a SysTime with the same std time as this one, but with UTC as its time zone.
  const pure nothrow @safe SysTime `toOtherTZ`(immutable TimeZone `tz`);
    Returns a SysTime with the same std time as this one, but with given time zone as its time zone.
  const pure nothrow @safe T `toUnixTime`(T = time_t)()
  if (is(T == int) || is(T == long));
    Converts this SysTime to unix time (i.e. seconds from midnight, January 1st, 1970 in UTC).
    The C standard does not specify the representation of time_t, so it is implementation defined. On POSIX systems, unix time is equivalent to time_t, but that's not necessarily `true` on other systems (e.g. it is not `true` for the Digital Mars C runtime). So, be careful when using unix time with C functions on non-POSIX systems.
    By default, the return type is time_t (which is normally an alias for int on 32-bit systems and long on 64-bit systems), but if a different size is required than either int or long can be passed as a template argument to get the desired size.
    If the return type is int, and the result can't fit in an int, then the closest value that can be held in 32 bits will be used (so int.max if it goes over and int.min if it goes under). However, no attempt is made to deal with integer overflow if the return type is long.
    Parameters:

    T | The return type (int or long). It defaults to time_t, which is normally 32 bits on a 32-bit system and 64 bits on a 64-bit system.

    Returns:
    A signed integer representing the unix time which is equivalent to this SysTime.
    Examples:

        import core.time : hours;
        import std.datetime.date : DateTime;
        import std.datetime.timezone : SimpleTimeZone, UTC;

        writeln(SysTime(DateTime(1970, 1, 1), UTC()).toUnixTime()); // 0

        auto pst = new immutable SimpleTimeZone(hours(-8));
        writeln(SysTime(DateTime(1970, 1, 1), pst).toUnixTime()); // 28800

        auto utc = SysTime(DateTime(2007, 12, 22, 8, 14, 45), UTC());
        writeln(utc.toUnixTime()); // 1_198_311_285

        auto ca = SysTime(DateTime(2007, 12, 22, 8, 14, 45), pst);
        writeln(ca.toUnixTime()); // 1_198_340_085

  static pure nothrow @safe SysTime `fromUnixTime`(long `unixTime`, immutable TimeZone `tz` = LocalTime());
    Converts from unix time (i.e. seconds from midnight, January 1st, 1970 in UTC) to a SysTime.
    The C standard does not specify the representation of time_t, so it is implementation defined. On POSIX systems, unix time is equivalent to time_t, but that's not necessarily `true` on other systems (e.g. it is not `true` for the Digital Mars C runtime). So, be careful when using unix time with C functions on non-POSIX systems.
    Parameters:

    long `unixTime` | Seconds from midnight, January 1st, 1970 in UTC.
    TimeZone `tz` | The time zone for the SysTime that's returned.

    Examples:

        import core.time : hours;
        import std.datetime.date : DateTime;
        import std.datetime.timezone : SimpleTimeZone, UTC;

        assert(SysTime.fromUnixTime(0) ==
               SysTime(DateTime(1970, 1, 1), UTC()));

        auto pst = new immutable SimpleTimeZone(hours(-8));
        assert(SysTime.fromUnixTime(28800) ==
               SysTime(DateTime(1970, 1, 1), pst));

        auto st1 = SysTime.fromUnixTime(1_198_311_285, UTC());
        writeln(st1); // SysTime(DateTime(2007, 12, 22, 8, 14, 45), UTC())
        assert(st1.timezone is UTC());
        writeln(st1); // SysTime(DateTime(2007, 12, 22, 0, 14, 45), pst)

        auto st2 = SysTime.fromUnixTime(1_198_311_285, pst);
        writeln(st2); // SysTime(DateTime(2007, 12, 22, 8, 14, 45), UTC())
        assert(st2.timezone is pst);
        writeln(st2); // SysTime(DateTime(2007, 12, 22, 0, 14, 45), pst)

  const pure nothrow @safe timeval `toTimeVal`();
    Returns a timeval which represents this SysTime.
    Note that like all conversions in std.datetime, this is a truncating conversion.
    If timeval.tv_sec is int, and the result can't fit in an int, then the closest value that can be held in 32 bits will be used for tv_sec. (so int.max if it goes over and int.min if it goes under).
  const pure nothrow @safe timespec `toTimeSpec`();
    Returns a timespec which represents this SysTime.
    This function is Posix-Only.
  const nothrow @safe tm `toTM`();
    Returns a tm which represents this SysTime.
  nothrow ref @safe SysTime `add`(string units)(long `value`, AllowDayOverflow `allowOverflow` = AllowDayOverflow.yes)
  if (units == "years" || units == "months");
    Adds the given number of years or months to this SysTime. A negative number will subtract.
    Note that if day overflow is allowed, and the date with the adjusted year/month overflows the number of days in the new month, then the month will be incremented by one, and the day set to the number of days overflowed. (e.g. if the day were 31 and the new month were June, then the month would be incremented to July, and the new day would be 1). If day overflow is not allowed, then the day will be set to the last valid day in the month (e.g. June 31st would become June 30th).
    Parameters:

    units | The type of units to `add` ("years" or "months").
    long `value` | The number of months or years to `add` to this SysTime.
    AllowDayOverflow `allowOverflow` | Whether the days should be allowed to overflow, causing the month to increment.

  nothrow ref @safe SysTime `roll`(string units)(long `value`, AllowDayOverflow `allowOverflow` = AllowDayOverflow.yes)
  if (units == "years");
    Adds the given number of years or months to this SysTime. A negative number will subtract.
    The difference between rolling and adding is that rolling does not affect larger units. Rolling a SysTime 12 months gets the exact same SysTime. However, the days can still be affected due to the differing number of days in each month.
    Because there are no units larger than years, there is no difference between adding and rolling years.
    Parameters:

    units | The type of units to add ("years" or "months").
    long `value` | The number of months or years to add to this SysTime.
    AllowDayOverflow `allowOverflow` | Whether the days should be allowed to overflow, causing the month to increment.

    Examples:

        import std.datetime.date : AllowDayOverflow, DateTime;

        auto st1 = SysTime(DateTime(2010, 1, 1, 12, 33, 33));
        st1.roll!"months"(1);
        writeln(st1); // SysTime(DateTime(2010, 2, 1, 12, 33, 33))

        auto st2 = SysTime(DateTime(2010, 1, 1, 12, 33, 33));
        st2.roll!"months"(-1);
        writeln(st2); // SysTime(DateTime(2010, 12, 1, 12, 33, 33))

        auto st3 = SysTime(DateTime(1999, 1, 29, 12, 33, 33));
        st3.roll!"months"(1);
        writeln(st3); // SysTime(DateTime(1999, 3, 1, 12, 33, 33))

        auto st4 = SysTime(DateTime(1999, 1, 29, 12, 33, 33));
        st4.roll!"months"(1, AllowDayOverflow.no);
        writeln(st4); // SysTime(DateTime(1999, 2, 28, 12, 33, 33))

        auto st5 = SysTime(DateTime(2000, 2, 29, 12, 30, 33));
        st5.roll!"years"(1);
        writeln(st5); // SysTime(DateTime(2001, 3, 1, 12, 30, 33))

        auto st6 = SysTime(DateTime(2000, 2, 29, 12, 30, 33));
        st6.roll!"years"(1, AllowDayOverflow.no);
        writeln(st6); // SysTime(DateTime(2001, 2, 28, 12, 30, 33))

  nothrow ref @safe SysTime `roll`(string units)(long `value`)
  if (units == "days");
    Adds the given number of units to this SysTime. A negative number will subtract.
    The difference between rolling and adding is that rolling does not affect larger units. For instance, rolling a SysTime one year's worth of days gets the exact same SysTime.
    Accepted units are "days", "minutes", "hours", "minutes", "seconds", "msecs", "usecs", and "hnsecs".
    Note that when rolling msecs, usecs or hnsecs, they all add up to a second. So, for example, rolling 1000 msecs is exactly the same as rolling 100,000 usecs.
    Parameters:

    units | The units to add.
    long `value` | The number of units to add to this SysTime.

    Examples:

        import core.time : msecs, hnsecs;
        import std.datetime.date : DateTime;

        auto st1 = SysTime(DateTime(2010, 1, 1, 11, 23, 12));
        st1.roll!"days"(1);
        writeln(st1); // SysTime(DateTime(2010, 1, 2, 11, 23, 12))
        st1.roll!"days"(365);
        writeln(st1); // SysTime(DateTime(2010, 1, 26, 11, 23, 12))
        st1.roll!"days"(-32);
        writeln(st1); // SysTime(DateTime(2010, 1, 25, 11, 23, 12))

        auto st2 = SysTime(DateTime(2010, 7, 4, 12, 0, 0));
        st2.roll!"hours"(1);
        writeln(st2); // SysTime(DateTime(2010, 7, 4, 13, 0, 0))

        auto st3 = SysTime(DateTime(2010, 2, 12, 12, 0, 0));
        st3.roll!"hours"(-1);
        writeln(st3); // SysTime(DateTime(2010, 2, 12, 11, 0, 0))

        auto st4 = SysTime(DateTime(2009, 12, 31, 0, 0, 0));
        st4.roll!"minutes"(1);
        writeln(st4); // SysTime(DateTime(2009, 12, 31, 0, 1, 0))

        auto st5 = SysTime(DateTime(2010, 1, 1, 0, 0, 0));
        st5.roll!"minutes"(-1);
        writeln(st5); // SysTime(DateTime(2010, 1, 1, 0, 59, 0))

        auto st6 = SysTime(DateTime(2009, 12, 31, 0, 0, 0));
        st6.roll!"seconds"(1);
        writeln(st6); // SysTime(DateTime(2009, 12, 31, 0, 0, 1))

        auto st7 = SysTime(DateTime(2010, 1, 1, 0, 0, 0));
        st7.roll!"seconds"(-1);
        writeln(st7); // SysTime(DateTime(2010, 1, 1, 0, 0, 59))

        auto dt = DateTime(2010, 1, 1, 0, 0, 0);
        auto st8 = SysTime(dt);
        st8.roll!"msecs"(1);
        writeln(st8); // SysTime(dt, msecs(1))

        auto st9 = SysTime(dt);
        st9.roll!"msecs"(-1);
        writeln(st9); // SysTime(dt, msecs(999))

        auto st10 = SysTime(dt);
        st10.roll!"hnsecs"(1);
        writeln(st10); // SysTime(dt, hnsecs(1))

        auto st11 = SysTime(dt);
        st11.roll!"hnsecs"(-1);
        writeln(st11); // SysTime(dt, hnsecs(9_999_999))

  const pure nothrow @safe SysTime `opBinary`(string op)(Duration `duration`)
  if (op == "+" || op == "-");
    Gives the result of adding or subtracting a core.time.Duration from this SysTime.
    The legal types of arithmetic for SysTime using this operator are

    SysTime | + | Duration | --> | SysTime
    SysTime | - | Duration | --> | SysTime

    Parameters:

    Duration `duration` | The core.time.Duration to add to or subtract from this SysTime.

    Examples:

        import core.time : hours, seconds;
        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(2015, 12, 31, 23, 59, 59)) + seconds(1) ==
               SysTime(DateTime(2016, 1, 1, 0, 0, 0)));

        assert(SysTime(DateTime(2015, 12, 31, 23, 59, 59)) + hours(1) ==
               SysTime(DateTime(2016, 1, 1, 0, 59, 59)));

        assert(SysTime(DateTime(2016, 1, 1, 0, 0, 0)) - seconds(1) ==
               SysTime(DateTime(2015, 12, 31, 23, 59, 59)));

        assert(SysTime(DateTime(2016, 1, 1, 0, 59, 59)) - hours(1) ==
               SysTime(DateTime(2015, 12, 31, 23, 59, 59)));

  pure nothrow ref @safe SysTime `opOpAssign`(string op)(Duration `duration`)
  if (op == "+" || op == "-");
    Gives the result of adding or subtracting a core.time.Duration from this SysTime, as well as assigning the result to this SysTime.
    The legal types of arithmetic for SysTime using this operator are

    SysTime | + | Duration | --> | SysTime
    SysTime | - | Duration | --> | SysTime

    Parameters:

    Duration `duration` | The core.time.Duration to add to or subtract from this SysTime.

  const pure nothrow @safe Duration `opBinary`(string op)(in SysTime `rhs`)
  if (op == "-");
    Gives the difference between two SysTimes.
    The legal types of arithmetic for SysTime using this operator are

    SysTime | - | SysTime | --> | duration

  const nothrow @safe int `diffMonths`(in SysTime `rhs`);
    Returns the difference between the two SysTimes in months.
    To get the difference in years, subtract the year property of two SysTimes. To get the difference in days or weeks, subtract the SysTimes themselves and use the core.time.Duration that results. Because converting between months and smaller units requires a specific date (which core.time.Durations don't have), getting the difference in months requires some math using both the year and month properties, so this is a convenience function for getting the difference in months.
    Note that the number of days in the months or how far into the month either date is is irrelevant. It is the difference in the month property combined with the difference in years * 12. So, for instance, December 31st and January 1st are one month apart just as December 1st and January 31st are one month apart.
    Parameters:

    SysTime `rhs` | The SysTime to subtract from this one.

    Examples:

        import std.datetime.date : Date;

        assert(SysTime(Date(1999, 2, 1)).diffMonths(
                   SysTime(Date(1999, 1, 31))) == 1);

        assert(SysTime(Date(1999, 1, 31)).diffMonths(
                   SysTime(Date(1999, 2, 1))) == -1);

        assert(SysTime(Date(1999, 3, 1)).diffMonths(
                   SysTime(Date(1999, 1, 1))) == 2);

        assert(SysTime(Date(1999, 1, 1)).diffMonths(
                   SysTime(Date(1999, 3, 31))) == -2);

  const nothrow @property @safe bool `isLeapYear`();
    Whether this SysTime is in a leap year.
  const nothrow @property @safe DayOfWeek `dayOfWeek`();
    Day of the week this SysTime is on.
  const nothrow @property @safe ushort `dayOfYear`();
    Day of the year this SysTime is on.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1999, 1, 1, 12, 22, 7)).dayOfYear); // 1
        writeln(SysTime(DateTime(1999, 12, 31, 7, 2, 59)).dayOfYear); // 365
        writeln(SysTime(DateTime(2000, 12, 31, 21, 20, 0)).dayOfYear); // 366

  @property @safe void `dayOfYear`(int `day`);
    Day of the year.
    Parameters:

    int `day` | The `day` of the year to set which `day` of the year this SysTime is on.

  const nothrow @property @safe int `dayOfGregorianCal`();
    The Xth day of the Gregorian Calendar that this SysTime is on.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1, 1, 1, 0, 0, 0)).dayOfGregorianCal); // 1
        writeln(SysTime(DateTime(1, 12, 31, 23, 59, 59)).dayOfGregorianCal); // 365
        writeln(SysTime(DateTime(2, 1, 1, 2, 2, 2)).dayOfGregorianCal); // 366

        writeln(SysTime(DateTime(0, 12, 31, 7, 7, 7)).dayOfGregorianCal); // 0
        writeln(SysTime(DateTime(0, 1, 1, 19, 30, 0)).dayOfGregorianCal); // -365
        writeln(SysTime(DateTime(-1, 12, 31, 4, 7, 0)).dayOfGregorianCal); // -366

        writeln(SysTime(DateTime(2000, 1, 1, 9, 30, 20)).dayOfGregorianCal); // 730_120
        writeln(SysTime(DateTime(2010, 12, 31, 15, 45, 50)).dayOfGregorianCal); // 734_137

  nothrow @property @safe void `dayOfGregorianCal`(int `days`);
    The Xth day of the Gregorian Calendar that this SysTime is on. Setting this property does not affect the time portion of SysTime.
    Parameters:

    int `days` | The day of the Gregorian Calendar to set this SysTime to.

    Examples:

        import std.datetime.date : DateTime;

        auto st = SysTime(DateTime(0, 1, 1, 12, 0, 0));
        st.dayOfGregorianCal = 1;
        writeln(st); // SysTime(DateTime(1, 1, 1, 12, 0, 0))

        st.dayOfGregorianCal = 365;
        writeln(st); // SysTime(DateTime(1, 12, 31, 12, 0, 0))

        st.dayOfGregorianCal = 366;
        writeln(st); // SysTime(DateTime(2, 1, 1, 12, 0, 0))

        st.dayOfGregorianCal = 0;
        writeln(st); // SysTime(DateTime(0, 12, 31, 12, 0, 0))

        st.dayOfGregorianCal = -365;
        writeln(st); // SysTime(DateTime(-0, 1, 1, 12, 0, 0))

        st.dayOfGregorianCal = -366;
        writeln(st); // SysTime(DateTime(-1, 12, 31, 12, 0, 0))

        st.dayOfGregorianCal = 730_120;
        writeln(st); // SysTime(DateTime(2000, 1, 1, 12, 0, 0))

        st.dayOfGregorianCal = 734_137;
        writeln(st); // SysTime(DateTime(2010, 12, 31, 12, 0, 0))

  const nothrow @property @safe ubyte `isoWeek`();
    The ISO 8601 week of the year that this SysTime is in.
    See Also:
    ISO Week Date.
    Examples:

        import std.datetime.date : Date;

        auto st = SysTime(Date(1999, 7, 6));
        const cst = SysTime(Date(2010, 5, 1));
        immutable ist = SysTime(Date(2015, 10, 10));

        writeln(st.isoWeek); // 27
        writeln(cst.isoWeek); // 17
        writeln(ist.isoWeek); // 41

  const nothrow @property @safe SysTime `endOfMonth`();
    SysTime for the last day in the month that this Date is in. The time portion of `endOfMonth` is always 23:59:59.9999999.
    Examples:

        import core.time : msecs, usecs, hnsecs;
        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(1999, 1, 6, 0, 0, 0)).endOfMonth ==
               SysTime(DateTime(1999, 1, 31, 23, 59, 59), hnsecs(9_999_999)));

        assert(SysTime(DateTime(1999, 2, 7, 19, 30, 0), msecs(24)).endOfMonth ==
               SysTime(DateTime(1999, 2, 28, 23, 59, 59), hnsecs(9_999_999)));

        assert(SysTime(DateTime(2000, 2, 7, 5, 12, 27), usecs(5203)).endOfMonth ==
               SysTime(DateTime(2000, 2, 29, 23, 59, 59), hnsecs(9_999_999)));

        assert(SysTime(DateTime(2000, 6, 4, 12, 22, 9), hnsecs(12345)).endOfMonth ==
               SysTime(DateTime(2000, 6, 30, 23, 59, 59), hnsecs(9_999_999)));

  const nothrow @property @safe ubyte `daysInMonth`();
    The last day in the month that this SysTime is in.
    Examples:

        import std.datetime.date : DateTime;

        writeln(SysTime(DateTime(1999, 1, 6, 0, 0, 0)).daysInMonth); // 31
        writeln(SysTime(DateTime(1999, 2, 7, 19, 30, 0)).daysInMonth); // 28
        writeln(SysTime(DateTime(2000, 2, 7, 5, 12, 27)).daysInMonth); // 29
        writeln(SysTime(DateTime(2000, 6, 4, 12, 22, 9)).daysInMonth); // 30

  const nothrow @property @safe bool `isAD`();
    Whether the current year is a date in A.D.
    Examples:

        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(1, 1, 1, 12, 7, 0)).isAD);
        assert(SysTime(DateTime(2010, 12, 31, 0, 0, 0)).isAD);
        assert(!SysTime(DateTime(0, 12, 31, 23, 59, 59)).isAD);
        assert(!SysTime(DateTime(-2010, 1, 1, 2, 2, 2)).isAD);

  const nothrow @property @safe long `julianDay`();
    The Julian day for this SysTime at the given time. For example, prior to noon, 1996-03-31 would be the Julian day number 2_450_173, so this function returns 2_450_173, while from noon onward, the Julian day number would be 2_450_174, so this function returns 2_450_174.
  const nothrow @property @safe long `modJulianDay`();
    The modified Julian day for any time on this date (since, the modified Julian day changes at midnight).
  const nothrow @safe Date `opCast`(T)()
  if (is(Unqual!T == Date));
    Returns a std.datetime.date.Date equivalent to this SysTime.
  const nothrow @safe DateTime `opCast`(T)()
  if (is(Unqual!T == DateTime));
    Returns a std.datetime.date.DateTime equivalent to this SysTime.
  const nothrow @safe TimeOfDay `opCast`(T)()
  if (is(Unqual!T == TimeOfDay));
    Returns a std.datetime.date.TimeOfDay equivalent to this SysTime.
  const nothrow @safe string `toISOString`();
    Converts this SysTime to a string with the format YYYYMMDDTHHMMSS.FFFFFFFTZ (where F is fractional seconds and TZ is time zone).
    Note that the number of digits in the fractional seconds varies with the number of fractional seconds. It's a maximum of 7 (which would be hnsecs), but only has as many as are necessary to hold the correct value (so no trailing zeroes), and if there are no fractional seconds, then there is no decimal point.
    If this SysTime's time zone is std.datetime.timezone.LocalTime, then TZ is empty. If its time zone is UTC, then it is "Z". Otherwise, it is the offset from UTC (e.g. +0100 or -0700). Note that the offset from UTC is not enough to uniquely identify the time zone.
    Time zone offsets will be in the form +HHMM or -HHMM.
    Warning: Previously, `toISOString` did the same as toISOExtString and generated +HH:MM or -HH:MM for the time zone when it was not std.datetime.timezone.LocalTime or std.datetime.timezone.UTC, which is not in conformance with ISO 8601 for the non-extended string format. This has now been fixed. However, for now, fromISOString will continue to accept the extended format for the time zone so that any code which has been writing out the result of `toISOString` to read in later will continue to work. The current behavior will be kept until July 2019 at which point, fromISOString will be fixed to be standards compliant.
    Examples:

        import core.time : msecs, hnsecs;
        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(2010, 7, 4, 7, 6, 12)).toISOString() ==
               "20100704T070612");

        assert(SysTime(DateTime(1998, 12, 25, 2, 15, 0), msecs(24)).toISOString() ==
               "19981225T021500.024");

        assert(SysTime(DateTime(0, 1, 5, 23, 9, 59)).toISOString() ==
               "00000105T230959");

        assert(SysTime(DateTime(-4, 1, 5, 0, 0, 2), hnsecs(520_920)).toISOString() ==
               "-00040105T000002.052092");

  const nothrow @safe string `toISOExtString`();
    Converts this SysTime to a string with the format YYYY-MM-DDTHH:MM:SS.FFFFFFFTZ (where F is fractional seconds and TZ is the time zone).
    Note that the number of digits in the fractional seconds varies with the number of fractional seconds. It's a maximum of 7 (which would be hnsecs), but only has as many as are necessary to hold the correct value (so no trailing zeroes), and if there are no fractional seconds, then there is no decimal point.
    If this SysTime's time zone is std.datetime.timezone.LocalTime, then TZ is empty. If its time zone is UTC, then it is "Z". Otherwise, it is the offset from UTC (e.g. +01:00 or -07:00). Note that the offset from UTC is not enough to uniquely identify the time zone.
    Time zone offsets will be in the form +HH:MM or -HH:MM.
    Examples:

        import core.time : msecs, hnsecs;
        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(2010, 7, 4, 7, 6, 12)).toISOExtString() ==
               "2010-07-04T07:06:12");

        assert(SysTime(DateTime(1998, 12, 25, 2, 15, 0), msecs(24)).toISOExtString() ==
               "1998-12-25T02:15:00.024");

        assert(SysTime(DateTime(0, 1, 5, 23, 9, 59)).toISOExtString() ==
               "0000-01-05T23:09:59");

        assert(SysTime(DateTime(-4, 1, 5, 0, 0, 2), hnsecs(520_920)).toISOExtString() ==
               "-0004-01-05T00:00:02.052092");

  const nothrow @safe string `toSimpleString`();
    Converts this SysTime to a string with the format YYYY-Mon-DD HH:MM:SS.FFFFFFFTZ (where F is fractional seconds and TZ is the time zone).
    Note that the number of digits in the fractional seconds varies with the number of fractional seconds. It's a maximum of 7 (which would be hnsecs), but only has as many as are necessary to hold the correct value (so no trailing zeroes), and if there are no fractional seconds, then there is no decimal point.
    If this SysTime's time zone is std.datetime.timezone.LocalTime, then TZ is empty. If its time zone is UTC, then it is "Z". Otherwise, it is the offset from UTC (e.g. +01:00 or -07:00). Note that the offset from UTC is not enough to uniquely identify the time zone.
    Time zone offsets will be in the form +HH:MM or -HH:MM.
    Examples:

        import core.time : msecs, hnsecs;
        import std.datetime.date : DateTime;

        assert(SysTime(DateTime(2010, 7, 4, 7, 6, 12)).toSimpleString() ==
               "2010-Jul-04 07:06:12");

        assert(SysTime(DateTime(1998, 12, 25, 2, 15, 0), msecs(24)).toSimpleString() ==
               "1998-Dec-25 02:15:00.024");

        assert(SysTime(DateTime(0, 1, 5, 23, 9, 59)).toSimpleString() ==
               "0000-Jan-05 23:09:59");

        assert(SysTime(DateTime(-4, 1, 5, 0, 0, 2), hnsecs(520_920)).toSimpleString() ==
                "-0004-Jan-05 00:00:02.052092");

  const nothrow @safe string `toString`();
    Converts this SysTime to a string.
    This function exists to make it easy to convert a SysTime to a string for code that does not care what the exact format is - just that it presents the information in a clear manner. It also makes it easy to simply convert a SysTime to a string when using functions such as to!string, format, or writeln which use `toString` to convert user-defined types. So, it is unlikely that much code will call `toString` directly.
    The format of the string is purposefully unspecified, and code that cares about the format of the string should use toISOString, toISOExtString, toSimpleString, or some other custom formatting function that explicitly generates the format that the code needs. The reason is that the code is then clear about what format it's using, making it less error-prone to maintain the code and interact with other software that consumes the generated strings. It's for this same reason that SysTime has no fromString function, whereas it does have fromISOString, fromISOExtString, and fromSimpleString.
    The format returned by `toString` may or may not change in the future.
  @safe SysTime `fromISOString`(S)(in S `isoString`, immutable TimeZone `tz` = null)
  if (isSomeString!S);
    Creates a SysTime from a string with the format YYYYMMDDTHHMMSS.FFFFFFFTZ (where F is fractional seconds is the time zone). Whitespace is stripped from the given string.
    The exact format is exactly as described in toISOString except that trailing zeroes are permitted - including having fractional seconds with all zeroes. However, a decimal point with nothing following it is invalid. Also, while toISOString will never generate a string with more than 7 digits in the fractional seconds (because that's the limit with hecto-nanosecond precision), it will allow more than 7 digits in order to read strings from other sources that have higher precision (however, any digits beyond 7 will be truncated).
    If there is no time zone in the string, then std.datetime.timezone.LocalTime is used. If the time zone is "Z", then UTC is used. Otherwise, a std.datetime.timezone.SimpleTimeZone which corresponds to the given offset from UTC is used. To get the returned SysTime to be a particular time zone, pass in that time zone and the SysTime to be returned will be converted to that time zone (though it will still be read in as whatever time zone is in its string).
    The accepted formats for time zone offsets are +HH, -HH, +HHMM, and -HHMM.
    Warning: Previously, toISOString did the same as toISOExtString and generated +HH:MM or -HH:MM for the time zone when it was not std.datetime.timezone.LocalTime or std.datetime.timezone.UTC, which is not in conformance with ISO 8601 for the non-extended string format. This has now been fixed. However, for now, `fromISOString` will continue to accept the extended format for the time zone so that any code which has been writing out the result of toISOString to read in later will continue to work. The current behavior will be kept until July 2019 at which point, `fromISOString` will be fixed to be standards compliant.
    Parameters:

    S `isoString` | A string formatted in the ISO format for dates and times.
    TimeZone `tz` | The time zone to convert the given time to (no conversion occurs if `null`).

    Throws:
    std.datetime.date.DateTimeException if the given string is not in the ISO format or if the resulting SysTime would not be valid.
  @safe SysTime `fromISOExtString`(S)(in S `isoExtString`, immutable TimeZone `tz` = null)
  if (isSomeString!S);
    Creates a SysTime from a string with the format YYYY-MM-DDTHH:MM:SS.FFFFFFFTZ (where F is fractional seconds is the time zone). Whitespace is stripped from the given string.
    The exact format is exactly as described in toISOExtString except that trailing zeroes are permitted - including having fractional seconds with all zeroes. However, a decimal point with nothing following it is invalid. Also, while toISOExtString will never generate a string with more than 7 digits in the fractional seconds (because that's the limit with hecto-nanosecond precision), it will allow more than 7 digits in order to read strings from other sources that have higher precision (however, any digits beyond 7 will be truncated).
    If there is no time zone in the string, then std.datetime.timezone.LocalTime is used. If the time zone is "Z", then UTC is used. Otherwise, a std.datetime.timezone.SimpleTimeZone which corresponds to the given offset from UTC is used. To get the returned SysTime to be a particular time zone, pass in that time zone and the SysTime to be returned will be converted to that time zone (though it will still be read in as whatever time zone is in its string).
    The accepted formats for time zone offsets are +HH, -HH, +HH:MM, and -HH:MM.
    Parameters:

    S `isoExtString` | A string formatted in the ISO Extended format for dates and times.
    TimeZone `tz` | The time zone to convert the given time to (no conversion occurs if `null`).

    Throws:
    std.datetime.date.DateTimeException if the given string is not in the ISO format or if the resulting SysTime would not be valid.
  @safe SysTime `fromSimpleString`(S)(in S `simpleString`, immutable TimeZone `tz` = null)
  if (isSomeString!S);
    Creates a SysTime from a string with the format YYYY-MM-DD HH:MM:SS.FFFFFFFTZ (where F is fractional seconds is the time zone). Whitespace is stripped from the given string.
    The exact format is exactly as described in toSimpleString except that trailing zeroes are permitted - including having fractional seconds with all zeroes. However, a decimal point with nothing following it is invalid. Also, while toSimpleString will never generate a string with more than 7 digits in the fractional seconds (because that's the limit with hecto-nanosecond precision), it will allow more than 7 digits in order to read strings from other sources that have higher precision (however, any digits beyond 7 will be truncated).
    If there is no time zone in the string, then std.datetime.timezone.LocalTime is used. If the time zone is "Z", then UTC is used. Otherwise, a std.datetime.timezone.SimpleTimeZone which corresponds to the given offset from UTC is used. To get the returned SysTime to be a particular time zone, pass in that time zone and the SysTime to be returned will be converted to that time zone (though it will still be read in as whatever time zone is in its string).
    The accepted formats for time zone offsets are +HH, -HH, +HH:MM, and -HH:MM.
    Parameters:

    S `simpleString` | A string formatted in the way that toSimpleString formats dates and times.
    TimeZone `tz` | The time zone to convert the given time to (no conversion occurs if `null`).

    Throws:
    std.datetime.date.DateTimeException if the given string is not in the ISO format or if the resulting SysTime would not be valid.
  static pure nothrow @property @safe SysTime `min`();
    Returns the SysTime farthest in the past which is representable by SysTime.
    The SysTime which is returned is in UTC.
  static pure nothrow @property @safe SysTime `max`();
    Returns the SysTime farthest in the future which is representable by SysTime.
    The SysTime which is returned is in UTC.
pure nothrow @safe long `unixTimeToStdTime`(long `unixTime`);
  Converts from unix time (which uses midnight, January 1st, 1970 UTC as its epoch and seconds as its units) to "std time" (which uses midnight, January 1st, 1 A.D. UTC and hnsecs as its units).
  The C standard does not specify the representation of time_t, so it is implementation defined. On POSIX systems, unix time is equivalent to time_t, but that's not necessarily `true` on other systems (e.g. it is not `true` for the Digital Mars C runtime). So, be careful when using unix time with C functions on non-POSIX systems.
  "std time"'s epoch is based on the Proleptic Gregorian Calendar per ISO 8601 and is what SysTime uses internally. However, holding the time as an integer in hnsecs since that epoch technically isn't actually part of the standard, much as it's based on it, so the name "std time" isn't particularly good, but there isn't an official name for it. C# uses "ticks" for the same thing, but they aren't actually clock ticks, and the term "ticks" is used for actual clock ticks for core.time.MonoTime, so it didn't make sense to use the term ticks here. So, for better or worse, std.datetime uses the term "std time" for this.
  Parameters:

  long `unixTime` | The unix time to convert.

  See Also:
  SysTime.fromUnixTime
  Examples:

      import std.datetime.date : DateTime;
      import std.datetime.timezone : UTC;

      // Midnight, January 1st, 1970
      writeln(unixTimeToStdTime(0)); // 621_355_968_000_000_000L
      assert(SysTime(unixTimeToStdTime(0)) ==
             SysTime(DateTime(1970, 1, 1), UTC()));

      writeln(unixTimeToStdTime(int.max)); // 642_830_804_470_000_000L
      assert(SysTime(unixTimeToStdTime(int.max)) ==
             SysTime(DateTime(2038, 1, 19, 3, 14, 07), UTC()));

      writeln(unixTimeToStdTime(-127_127)); // 621_354_696_730_000_000L
      assert(SysTime(unixTimeToStdTime(-127_127)) ==
             SysTime(DateTime(1969, 12, 30, 12, 41, 13), UTC()));

pure nothrow @safe T `stdTimeToUnixTime`(T = time_t)(long `stdTime`)
if (is(T == int) || is(T == long));
  Converts std time (which uses midnight, January 1st, 1 A.D. UTC as its epoch and hnsecs as its units) to unix time (which uses midnight, January 1st, 1970 UTC as its epoch and seconds as its units).
  The C standard does not specify the representation of time_t, so it is implementation defined. On POSIX systems, unix time is equivalent to time_t, but that's not necessarily `true` on other systems (e.g. it is not `true` for the Digital Mars C runtime). So, be careful when using unix time with C functions on non-POSIX systems.
  "std time"'s epoch is based on the Proleptic Gregorian Calendar per ISO 8601 and is what SysTime uses internally. However, holding the time as an integer in hnescs since that epoch technically isn't actually part of the standard, much as it's based on it, so the name "std time" isn't particularly good, but there isn't an official name for it. C# uses "ticks" for the same thing, but they aren't actually clock ticks, and the term "ticks" is used for actual clock ticks for core.time.MonoTime, so it didn't make sense to use the term ticks here. So, for better or worse, std.datetime uses the term "std time" for this.
  By default, the return type is time_t (which is normally an alias for int on 32-bit systems and long on 64-bit systems), but if a different size is required than either int or long can be passed as a template argument to get the desired size.
  If the return type is int, and the result can't fit in an int, then the closest value that can be held in 32 bits will be used (so int.max if it goes over and int.min if it goes under). However, no attempt is made to deal with integer overflow if the return type is long.
  Parameters:

  T | The return type (int or long). It defaults to time_t, which is normally 32 bits on a 32-bit system and 64 bits on a 64-bit system.
  long `stdTime` | The std time to convert.

  Returns:
  A signed integer representing the unix time which is equivalent to the given std time.
  See Also:
  SysTime.toUnixTime
  Examples:

      // Midnight, January 1st, 1970 UTC
      writeln(stdTimeToUnixTime(621_355_968_000_000_000L)); // 0

      // 2038-01-19 03:14:07 UTC
      writeln(stdTimeToUnixTime(642_830_804_470_000_000L)); // int.max

@safe SysTime `SYSTEMTIMEToSysTime`(const SYSTEMTIME* `st`, immutable TimeZone `tz` = LocalTime());
  This function is Windows-Only.
  Converts a SYSTEMTIME struct to a SysTime.
  Parameters:

  SYSTEMTIME* `st` | The SYSTEMTIME struct to convert.
  TimeZone `tz` | The time zone that the time in the SYSTEMTIME struct is assumed to be (if the SYSTEMTIME was supplied by a Windows system call, the SYSTEMTIME will either be in local time or UTC, depending on the call).

  Throws:
  std.datetime.date.DateTimeException if the given SYSTEMTIME will not fit in a SysTime, which is highly unlikely to happen given that SysTime.max is in 29,228 A.D. and the maximum SYSTEMTIME is in 30,827 A.D.
@safe SYSTEMTIME `SysTimeToSYSTEMTIME`(in SysTime `sysTime`);
  This function is Windows-Only.
  Converts a SysTime to a SYSTEMTIME struct.
  The SYSTEMTIME which is returned will be set using the given SysTime's time zone, so to get the SYSTEMTIME in UTC, set the SysTime's time zone to UTC.
  Parameters:

  SysTime `sysTime` | The SysTime to convert.

  Throws:
  std.datetime.date.DateTimeException if the given SysTime will not fit in a SYSTEMTIME. This will only happen if the SysTime's date is prior to 1601 A.D.
@safe long `FILETIMEToStdTime`(scope const FILETIME* `ft`);
  This function is Windows-Only.
  Converts a FILETIME struct to the number of hnsecs since midnight, January 1st, 1 A.D.
  Parameters:

  FILETIME* `ft` | The FILETIME struct to convert.

  Throws:
  std.datetime.date.DateTimeException if the given FILETIME cannot be represented as the return value.
@safe SysTime `FILETIMEToSysTime`(scope const FILETIME* `ft`, immutable TimeZone `tz` = LocalTime());
  This function is Windows-Only.
  Converts a FILETIME struct to a SysTime.
  Parameters:

  FILETIME* `ft` | The FILETIME struct to convert.
  TimeZone `tz` | The time zone that the SysTime will be in (FILETIMEs are in UTC).

  Throws:
  std.datetime.date.DateTimeException if the given FILETIME will not fit in a SysTime.
@safe FILETIME `stdTimeToFILETIME`(long `stdTime`);
  This function is Windows-Only.
  Converts a number of hnsecs since midnight, January 1st, 1 A.D. to a FILETIME struct.
  Parameters:

  long `stdTime` | The number of hnsecs since midnight, January 1st, 1 A.D. UTC.

  Throws:
  std.datetime.date.DateTimeException if the given value will not fit in a FILETIME.
@safe FILETIME `SysTimeToFILETIME`(SysTime `sysTime`);
  This function is Windows-Only.
  Converts a SysTime to a FILETIME struct.
  FILETIMEs are always in UTC.
  Parameters:

  SysTime `sysTime` | The SysTime to convert.

  Throws:
  std.datetime.date.DateTimeException if the given SysTime will not fit in a FILETIME.
alias `DosFileTime` = uint;
  Type representing the DOS file date/time format.
@safe SysTime `DosFileTimeToSysTime`(DosFileTime `dft`, immutable TimeZone `tz` = LocalTime());
  Converts from DOS file date/time to SysTime.
  Parameters:

  DosFileTime `dft` | The DOS file time to convert.
  TimeZone `tz` | The time zone which the DOS file time is assumed to be in.

  Throws:
  std.datetime.date.DateTimeException if the DosFileTime is invalid.
@safe DosFileTime `SysTimeToDosFileTime`(SysTime `sysTime`);
  Converts from SysTime to DOS file date/time.
  Parameters:

  SysTime `sysTime` | The SysTime to convert.

  Throws:
  std.datetime.date.DateTimeException if the given SysTime cannot be converted to a DosFileTime.
@safe SysTime `parseRFC822DateTime`()(in char[] `value`);
@safe SysTime `parseRFC822DateTime`(R)(R `value`)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && (is(Unqual!(ElementType!R) == char) || is(Unqual!(ElementType!R) == ubyte)));
  The given array of char or random-access range of char or ubyte is expected to be in the format specified in RFC 5322 section 3.3 with the grammar rule date-time. It is the date-time format commonly used in internet messages such as e-mail and HTTP. The corresponding SysTime will be returned.
  RFC 822 was the original spec (hence the function's name), whereas RFC 5322 is the current spec.
  The day of the week is ignored beyond verifying that it's a valid day of the week, as the day of the week can be inferred from the date. It is not checked whether the given day of the week matches the actual day of the week of the given date (though it is technically invalid per the spec if the day of the week doesn't match the actual day of the week of the given date).
  If the time zone is "-0000" (or considered to be equivalent to "-0000" by section 4.3 of the spec), a std.datetime.timezone.SimpleTimeZone with a utc offset of 0 is used rather than std.datetime.timezone.UTC, whereas "+0000" uses std.datetime.timezone.UTC.
  Note that because SysTime does not currently support having a second `value` of 60 (as is sometimes done for leap seconds), if the date-time `value` does have a `value` of 60 for the seconds, it is treated as 59.
  The one area in which this function violates RFC 5322 is that it accepts "\n" in folding whitespace in the place of "\r\n", because the HTTP spec requires it.
  Throws:
  std.datetime.date.DateTimeException if the given string doesn't follow the grammar for a date-time field or if the resulting SysTime is invalid.
  Examples:

      import core.time : hours;
      import std.datetime.date : DateTime, DateTimeException;
      import std.datetime.timezone : SimpleTimeZone, UTC;
      import std.exception : assertThrown;

      auto tz = new immutable SimpleTimeZone(hours(-8));
      assert(parseRFC822DateTime("Sat, 6 Jan 1990 12:14:19 -0800") ==
             SysTime(DateTime(1990, 1, 6, 12, 14, 19), tz));

      assert(parseRFC822DateTime("9 Jul 2002 13:11 +0000") ==
             SysTime(DateTime(2002, 7, 9, 13, 11, 0), UTC()));

      auto badStr = "29 Feb 2001 12:17:16 +0200";
      assertThrown!DateTimeException(parseRFC822DateTime(badStr));

Copyright © 1999-2018 by the D Language Foundation | Page generated by Ddoc on Tue Jan 2 20:55:08 2018