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
local clone.
Page wiki
View or edit the community-maintained wiki page associated with this page.

# core.time

Module containing core time functionality, such as Duration (which represents a duration of time). Various functions take a string (or strings) to represent a unit of time (e.g. convert!("days", "hours")(numDays)). The valid strings to use with such functions are "years", "months", "weeks", "days", "hours", "minutes", "seconds", "msecs" (milliseconds), "usecs" (microseconds), "hnsecs" (hecto-nanoseconds - i.e. 100 ns) or some subset thereof. There are a few functions that also allow "nsecs", but very little actually has precision greater than hnsecs.Symbol | Description |
---|---|

Types | |

Duration | Represents a duration of time of weeks or less (kept internally as hnsecs). (e.g. 22 days or 700 seconds). |

TickDuration | Represents a duration of time in system clock ticks, using the highest precision that the system provides. |

FracSec | Represents fractional seconds (portions of time smaller than a second). |

Functions | |

convert | Generic way of converting between two time units. |

dur | Allow constructing a Duration from the given time units with the given length. |

weeks days hours minutes seconds msecs usecs hnsecs nsecs |
Short-hands for dur. |

abs | Returns the absolute value of a duration. |

From Duration | From TickDuration | From FracSec | From units | |
---|---|---|---|---|

To Duration |
- | tickDuration.to!Duration() | - | dur!"msecs"(5) or 5.msecs() |

To TickDuration |
duration.to!TickDuration() | - | - | TickDuration.from!"msecs"(msecs) |

To FracSec |
duration.fracSec | - | - | FracSec.from!"msecs"(msecs) |

To units |
duration.total!"days" | tickDuration.msecs | fracSec.msecs | convert!("days", "msecs")(msecs) |

**License:**

Boost License 1.0.

**Authors:**

Jonathan M Davis and Kato Shoichi

**Source:**

core/time.d

- struct Duration;
- Represents a duration of time of weeks or less (kept internally as hnsecs).
(e.g. 22 days or 700 seconds).
It is used when representing a duration of time - such as how long to
sleep with core.Thread.sleep.
In std.datetime, it is also used as the result of various arithmetic
operations on time points.
Use the dur function or on of its non-generic aliases to create
Durations.
It's not possible to create a Duration of months or years, because the
variable number of days in a month or year makes it impossible to convert
between months or years and smaller units without a specific date. So,
nothing uses Durations when dealing with months or years. Rather,
functions specific to months and years are defined. For instance,
std.datetime.Date has add!"years" and add!"months" for adding
years and months rather than creating a Duration of years or months and
adding that to a std.datetime.Date. But Duration is used when dealing
with weeks or smaller.
**Examples:**import core.time; // using the dur template auto numDays = dur!"days"(12); // using the days function numDays = days(12); // alternatively using UFCS syntax numDays = 12.days; auto myTime = 100.msecs + 20_000.usecs + 30_000.hnsecs; assert(myTime == 123.msecs);

- static pure nothrow @property @safe Duration zero();
- A Duration of 0. It's shorter than doing something like dur!"seconds"(0) and more explicit than Duration.init.
- static pure nothrow @property @safe Duration max();
- Largest Duration possible.
- static pure nothrow @property @safe Duration min();
- Most negative Duration possible.
- const pure nothrow @safe int opCmp(Duration
*rhs*); - Compares this Duration with the given Duration.
**Returns:**this < *rhs*< 0 this == *rhs*0 this > *rhs*> 0 this < *rhs*< 0 this == *rhs*0 this > *rhs*> 0 - const pure nothrow @safe Duration opBinary(string op, D)(D
*rhs*) if ((op == "+" || op == "-") && (is(_Unqual!D == Duration) || is(_Unqual!D == TickDuration))); - Adds or subtracts two durations.
The legal types of arithmetic for Duration using this operator are
Duration + Duration --> Duration Duration - Duration --> Duration Duration + TickDuration --> Duration Duration - TickDuration --> Duration Duration + Duration --> Duration Duration - Duration --> Duration Duration + TickDuration --> Duration Duration - TickDuration --> Duration **Parameters:**D rhs The duration to add to or subtract from this Duration. - const pure nothrow @safe Duration opBinaryRight(string op, D)(D
*lhs*) if ((op == "+" || op == "-") && is(_Unqual!D == TickDuration)); - Adds or subtracts two durations.
The legal types of arithmetic for Duration using this operator are
TickDuration + Duration --> Duration TickDuration - Duration --> Duration TickDuration + Duration --> Duration TickDuration - Duration --> Duration **Parameters:**D lhs The TickDuration to add to this Duration or to subtract this Duration from. - pure nothrow ref @safe Duration opOpAssign(string op, D)(in D
*rhs*) if ((op == "+" || op == "-") && (is(_Unqual!D == Duration) || is(_Unqual!D == TickDuration))); - Adds or subtracts two durations as well as assigning the result to this
Duration.
The legal types of arithmetic for Duration using this operator are
Duration + Duration --> Duration Duration - Duration --> Duration Duration + TickDuration --> Duration Duration - TickDuration --> Duration Duration + Duration --> Duration Duration - Duration --> Duration Duration + TickDuration --> Duration Duration - TickDuration --> Duration **Parameters:**D rhs The duration to add to or subtract from this Duration. - const pure nothrow @safe Duration opBinary(string op)(long
*value*) if (op == "*"); - The legal types of arithmetic for Duration using this operator
overload are
Duration * long --> Duration Duration * long --> Duration **Parameters:**long value The value to multiply this Duration by. - pure nothrow ref @safe Duration opOpAssign(string op)(long
*value*) if (op == "*"); - The legal types of arithmetic for Duration using this operator
overload are
Duration * long --> Duration Duration * long --> Duration **Parameters:**long value The value to multiply this Duration by. - const pure @safe Duration opBinary(string op)(long
*value*) if (op == "/"); - The legal types of arithmetic for Duration using this operator
overload are
Duration / long --> Duration Duration / long --> Duration **Parameters:**long value The value to divide from this duration. **Throws:**

TimeException if an attempt to divide by 0 is made. - pure ref @safe Duration opOpAssign(string op)(long
*value*) if (op == "/"); - The legal types of arithmetic for Duration using this operator
overload are
Duration / long --> Duration Duration / long --> Duration **Parameters:**long value The value to divide from this Duration. **Throws:**

TimeException if an attempt to divide by 0 is made. - const pure nothrow @safe Duration opBinaryRight(string op)(long
*value*) if (op == "*"); - Multiplies an integral value and a Duration.
The legal types of arithmetic for Duration using this operator
overload are
long * Duration --> Duration long * Duration --> Duration **Parameters:**long value The number of units to multiply this Duration by. - const pure nothrow @safe Duration opUnary(string op)() if (op == "-");
- Returns the negation of this Duration.
- const pure nothrow @safe TickDuration opCast(T)() if (is(_Unqual!T == TickDuration));
- Returns a TickDuration with the same number of hnsecs as this Duration. Note that the conventional way to convert between Duration and TickDuration is using std.conv.to, e.g.: duration.to!TickDuration()
- template split(units...) if (allAreAcceptedUnits!("weeks", "days", "hours", "minutes", "seconds", "msecs", "usecs", "hnsecs", "nsecs")(units) && unitsAreInDescendingOrder(units))
- Splits out the Duration into the given units.
split takes the list of time units to split out as template arguments.
The time unit strings must be given in decreasing order. How it returns
the values for those units depends on the overload used.
The overload which accepts function arguments takes integral types in
the order that the time unit strings were given, and those integers are
passed by ref. split assigns the values for the units to each
corresponding integer. Any integral type may be used, but no attempt is
made to prevent integer overflow, so don't use small integral types in
circumstances where the values for those units aren't likely to fit in
an integral type that small.
The overload with no arguments returns the values for the units in a
struct with members whose names are the same as the given time unit
strings. The members are all longs. This overload will also work
with no time strings being given, in which case
*all*of the time units from weeks through hnsecs will be provided (but no nsecs, since it would always be 0). For both overloads, the entire value of the Duration is split among the units (rather than splitting the Duration across all units and then only providing the values for the requested units), so if only one unit is given, the result is equivalent to total. "nsecs" is accepted by split, but "years" and "months" are not. For negative durations, all of the split values will be negative.**Examples:**{ auto d = dur!"days"(12) + dur!"minutes"(7) + dur!"usecs"(501223); long days; int seconds; short msecs; d.split!("days", "seconds", "msecs")(days, seconds, msecs); assert(days == 12); assert(seconds == 7 * 60); assert(msecs == 501); auto splitStruct = d.split!("days", "seconds", "msecs")(); assert(splitStruct.days == 12); assert(splitStruct.seconds == 7 * 60); assert(splitStruct.msecs == 501); auto fullSplitStruct = d.split(); assert(fullSplitStruct.weeks == 1); assert(fullSplitStruct.days == 5); assert(fullSplitStruct.hours == 0); assert(fullSplitStruct.minutes == 7); assert(fullSplitStruct.seconds == 0); assert(fullSplitStruct.msecs == 501); assert(fullSplitStruct.usecs == 223); assert(fullSplitStruct.hnsecs == 0); assert(d.split!"minutes"().minutes == d.total!"minutes"); } { auto d = dur!"days"(12); assert(d.split!"weeks"().weeks == 1); assert(d.split!"days"().days == 12); assert(d.split().weeks == 1); assert(d.split().days == 5); } { auto d = dur!"days"(7) + dur!"hnsecs"(42); assert(d.split!("seconds", "nsecs")().nsecs == 4200); } { auto d = dur!"days"(-7) + dur!"hours"(-9); auto result = d.split!("days", "hours")(); assert(result.days == -7); assert(result.hours == -9); }

- const pure nothrow @safe long get(string units)() if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds");
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of the given units in this Duration
(minus the larger units).
d.get!"minutes"() is equivalent to d.split().minutes.
**Examples:**assert(dur!"weeks"(12).get!"weeks" == 12); assert(dur!"weeks"(12).get!"days" == 0); assert(dur!"days"(13).get!"weeks" == 1); assert(dur!"days"(13).get!"days" == 6); assert(dur!"hours"(49).get!"days" == 2); assert(dur!"hours"(49).get!"hours" == 1);

- deprecated const pure nothrow @property @safe long weeks();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of weeks in this Duration
(minus the larger units).
**Examples:**assert(dur!"weeks"(12).weeks == 12); assert(dur!"days"(13).weeks == 1);

- deprecated const pure nothrow @property @safe long days();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of days in this Duration
(minus the larger units).
**Examples:**assert(dur!"weeks"(12).days == 0); assert(dur!"days"(13).days == 6); assert(dur!"hours"(49).days == 2);

- deprecated const pure nothrow @property @safe long hours();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of hours in this Duration
(minus the larger units).
**Examples:**assert(dur!"days"(8).hours == 0); assert(dur!"hours"(49).hours == 1); assert(dur!"minutes"(121).hours == 2);

- deprecated const pure nothrow @property @safe long minutes();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of minutes in this Duration
(minus the larger units).
**Examples:**assert(dur!"hours"(47).minutes == 0); assert(dur!"minutes"(127).minutes == 7); assert(dur!"seconds"(121).minutes == 2);

- deprecated const pure nothrow @property @safe long seconds();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the number of seconds in this Duration
(minus the larger units).
**Examples:**assert(dur!"minutes"(47).seconds == 0); assert(dur!"seconds"(127).seconds == 7); assert(dur!"msecs"(1217).seconds == 1);

- deprecated const pure nothrow @property @safe FracSec fracSec();
- Deprecated. Please use split instead. Too frequently,
get or one of the individual unit getters is used when the
function that gave the desired behavior was total. This
should make it more explicit and help prevent bugs. This function
will be removed in June 2015.
Returns the fractional seconds past the second in this Duration.
**Examples:**assert(dur!"msecs"(1000).fracSec == FracSec.from!"msecs"(0)); assert(dur!"msecs"(1217).fracSec == FracSec.from!"msecs"(217)); assert(dur!"usecs"(43).fracSec == FracSec.from!"usecs"(43)); assert(dur!"hnsecs"(50_007).fracSec == FracSec.from!"hnsecs"(50_007)); assert(dur!"nsecs"(62_127).fracSec == FracSec.from!"nsecs"(62_100)); assert(dur!"msecs"(-1000).fracSec == FracSec.from!"msecs"(-0)); assert(dur!"msecs"(-1217).fracSec == FracSec.from!"msecs"(-217)); assert(dur!"usecs"(-43).fracSec == FracSec.from!"usecs"(-43)); assert(dur!"hnsecs"(-50_007).fracSec == FracSec.from!"hnsecs"(-50_007)); assert(dur!"nsecs"(-62_127).fracSec == FracSec.from!"nsecs"(-62_100));

- const pure nothrow @property @safe long total(string units)() if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");
- Returns the total number of the given units in this Duration.
So, unlike split, it does not strip out the larger units.
**Examples:**assert(dur!"weeks"(12).total!"weeks" == 12); assert(dur!"weeks"(12).total!"days" == 84); assert(dur!"days"(13).total!"weeks" == 1); assert(dur!"days"(13).total!"days" == 13); assert(dur!"hours"(49).total!"days" == 2); assert(dur!"hours"(49).total!"hours" == 49); assert(dur!"nsecs"(2007).total!"hnsecs" == 20); assert(dur!"nsecs"(2007).total!"nsecs" == 2000);

- const pure nothrow @safe string toString();
- Converts this Duration to a string.
- const pure nothrow @property @safe bool isNegative();
- Returns whether this Duration is negative.

- pure nothrow @safe Duration dur(string units)(long
*length*) if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

alias weeks = dur!"weeks".dur;

alias days = dur!"days".dur;

alias hours = dur!"hours".dur;

alias minutes = dur!"minutes".dur;

alias seconds = dur!"seconds".dur;

alias msecs = dur!"msecs".dur;

alias usecs = dur!"usecs".dur;

alias hnsecs = dur!"hnsecs".dur;

alias nsecs = dur!"nsecs".dur; - These allow you to construct a Duration from the given time units
with the given length.
You can either use the generic function dur and give it the units as
a string or use the named aliases.
The possible values for units are "weeks", "days", "hours",
"minutes", "seconds", "msecs" (milliseconds), "usecs",
(microseconds), "hnsecs" (hecto-nanoseconds, i.e. 100 ns), and
"nsecs".
**Examples:**// Generic assert(dur!"weeks"(142).total!"weeks" == 142); assert(dur!"days"(142).total!"days" == 142); assert(dur!"hours"(142).total!"hours" == 142); assert(dur!"minutes"(142).total!"minutes" == 142); assert(dur!"seconds"(142).total!"seconds" == 142); assert(dur!"msecs"(142).total!"msecs" == 142); assert(dur!"usecs"(142).total!"usecs" == 142); assert(dur!"hnsecs"(142).total!"hnsecs" == 142); assert(dur!"nsecs"(142).total!"nsecs" == 100); // Non-generic assert(weeks(142).total!"weeks" == 142); assert(days(142).total!"days" == 142); assert(hours(142).total!"hours" == 142); assert(minutes(142).total!"minutes" == 142); assert(seconds(142).total!"seconds" == 142); assert(msecs(142).total!"msecs" == 142); assert(usecs(142).total!"usecs" == 142); assert(hnsecs(142).total!"hnsecs" == 142); assert(nsecs(142).total!"nsecs" == 100);

**Parameters:**units The time units of the Duration (e.g. "days"). long length The number of units in the Duration. - struct TickDuration;
- Represents a duration of time in system clock ticks.
The system clock ticks are the ticks of the system clock at the highest
precision that the system provides.
- static immutable long ticksPerSec;
- The number of ticks that the system clock has in one second. If ticksPerSec is 0, then then TickDuration failed to get the value of ticksPerSec on the current system, and TickDuration is not going to work. That would be highly abnormal though.
- static immutable TickDuration appOrigin;
- The tick of the system clock (as a TickDuration) when the application started.
- static pure nothrow @property @safe TickDuration zero();
- It's the same as TickDuration(0), but it's provided to be consistent with Duration and FracSec, which provide zero properties.
- static pure nothrow @property @safe TickDuration max();
- Largest TickDuration possible.
- static pure nothrow @property @safe TickDuration min();
- Most negative TickDuration possible.
- long length;
- The number of system ticks in this TickDuration. You can convert this length into the number of seconds by dividing it by ticksPerSec (or using one the appropriate property function to do it).
- const pure nothrow @safe T to(string units, T)() if ((units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs") && (__traits(isIntegral, T) && T.sizeof >= 4 || __traits(isFloating, T)));
- Converts this TickDuration to the given units as either an integral
value or a floating point value.
**Parameters:**units The units to convert to. Accepts "seconds" and smaller only. T The type to convert to (either an integral type or a floating point type). - const pure nothrow @property @safe long seconds();
- Returns the total number of seconds in this TickDuration.
- const pure nothrow @property @safe long msecs();
- Returns the total number of milliseconds in this TickDuration.
- const pure nothrow @property @safe long usecs();
- Returns the total number of microseconds in this TickDuration.
- const pure nothrow @property @safe long hnsecs();
- Returns the total number of hecto-nanoseconds in this TickDuration.
- const pure nothrow @property @safe long nsecs();
- Returns the total number of nanoseconds in this TickDuration.
- pure nothrow @safe TickDuration from(string units)(long
*length*) if (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs"); - This allows you to construct a TickDuration from the given time
units with the given length.
**Parameters:**units The time units of the TickDuration (e.g. "msecs"). long length The number of units in the TickDuration. - const pure nothrow @safe Duration opCast(T)() if (is(_Unqual!T == Duration));
- Returns a Duration with the same number of hnsecs as this TickDuration. Note that the conventional way to convert between TickDuration and Duration is using std.conv.to, e.g.: tickDuration.to!Duration()
- pure nothrow ref @safe TickDuration opOpAssign(string op)(TickDuration
*rhs*) if (op == "+" || op == "-"); - Adds or subtracts two TickDurations as well as assigning the result
to this TickDuration.
The legal types of arithmetic for TickDuration using this operator
are
TickDuration += TickDuration --> TickDuration TickDuration -= TickDuration --> TickDuration TickDuration += TickDuration --> TickDuration TickDuration -= TickDuration --> TickDuration **Parameters:**TickDuration rhs The TickDuration to add to or subtract from this TickDuration. - const pure nothrow @safe TickDuration opBinary(string op)(TickDuration
*rhs*) if (op == "+" || op == "-"); - Adds or subtracts two TickDurations.
The legal types of arithmetic for TickDuration using this operator
are
TickDuration + TickDuration --> TickDuration TickDuration - TickDuration --> TickDuration TickDuration + TickDuration --> TickDuration TickDuration - TickDuration --> TickDuration **Parameters:**TickDuration rhs The TickDuration to add to or subtract from this TickDuration. - const pure nothrow @safe TickDuration opUnary(string op)() if (op == "-");
- Returns the negation of this TickDuration.
- const pure nothrow @safe int opCmp(TickDuration
*rhs*); - operator overloading "<, >, <=, >="
- pure nothrow @safe void opOpAssign(string op, T)(T
*value*) if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T))); - The legal types of arithmetic for TickDuration using this operator
overload are
TickDuration * long --> TickDuration TickDuration * floating point --> TickDuration TickDuration * long --> TickDuration TickDuration * floating point --> TickDuration **Parameters:**T value The value to divide from this duration. - pure @safe void opOpAssign(string op, T)(T
*value*) if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T))); - The legal types of arithmetic for TickDuration using this operator
overload are
TickDuration / long --> TickDuration TickDuration / floating point --> TickDuration TickDuration / long --> TickDuration TickDuration / floating point --> TickDuration **Parameters:**T value The value to divide from this TickDuration. **Throws:**

TimeException if an attempt to divide by 0 is made. - const pure nothrow @safe TickDuration opBinary(string op, T)(T
*value*) if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T))); - The legal types of arithmetic for TickDuration using this operator
overload are
TickDuration * long --> TickDuration TickDuration * floating point --> TickDuration TickDuration * long --> TickDuration TickDuration * floating point --> TickDuration **Parameters:**T value The value to divide from this TickDuration. - const pure @safe TickDuration opBinary(string op, T)(T
*value*) if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T))); - The legal types of arithmetic for TickDuration using this operator
overload are
TickDuration / long --> TickDuration TickDuration / floating point --> TickDuration TickDuration / long --> TickDuration TickDuration / floating point --> TickDuration **Parameters:**T value The value to divide from this TickDuration. **Throws:**

TimeException if an attempt to divide by 0 is made. - pure nothrow @safe this(long
*ticks*); **Parameters:**long *ticks*The number of *ticks*in the TickDuration.- static nothrow @property @trusted TickDuration currSystemTick();
- The current system tick. The number of ticks per second varies from
system to system. currSystemTick uses a monotonic clock, so it's
intended for precision timing by comparing relative time values, not for
getting the current system time.
On Windows, QueryPerformanceCounter is used. On Mac OS X,
mach_absolute_time is used, while on other Posix systems,
clock_gettime is used. If mach_absolute_time or
clock_gettime is unavailable, then Posix systems use
gettimeofday (the decision is made when TickDuration is
compiled), which unfortunately, is not monotonic, but if
mach_absolute_time and clock_gettime aren't available, then
gettimeofday is the the best that there is.
Warning:
On some systems, the monotonic clock may stop counting when
the computer goes to sleep or hibernates. So, the monotonic
clock could be off if that occurs. This is known to happen
on Mac OS X. It has not been tested whether it occurs on
either Windows or on Linux.
**Throws:**

TimeException if it fails to get the time.

- pure nothrow @safe long convert(string from, string to)(long
*value*) if ((from == "weeks" || from == "days" || from == "hours" || from == "minutes" || from == "seconds" || from == "msecs" || from == "usecs" || from == "hnsecs" || from == "nsecs") && (to == "weeks" || to == "days" || to == "hours" || to == "minutes" || to == "seconds" || to == "msecs" || to == "usecs" || to == "hnsecs" || to == "nsecs") || (from == "years" || from == "months") && (to == "years" || to == "months")); - Generic way of converting between two time units. Conversions to smaller
units use truncating division. Years and months can be converted to each
other, small units can be converted to each other, but years and months
cannot be converted to or from smaller units (due to the varying number
of days in a month or year).
**Parameters:**from The units of time to convert from. to The units of time to convert to. long value The value to convert. **Examples:**assert(convert!("years", "months")(1) == 12); assert(convert!("months", "years")(12) == 1); assert(convert!("weeks", "days")(1) == 7); assert(convert!("hours", "seconds")(1) == 3600); assert(convert!("seconds", "days")(1) == 0); assert(convert!("seconds", "days")(86_400) == 1); assert(convert!("nsecs", "nsecs")(1) == 1); assert(convert!("nsecs", "hnsecs")(1) == 0); assert(convert!("hnsecs", "nsecs")(1) == 100); assert(convert!("nsecs", "seconds")(1) == 0); assert(convert!("seconds", "nsecs")(1) == 1_000_000_000);

- struct FracSec;
- Represents fractional seconds.
This is the portion of the time which is smaller than a second and it cannot
hold values which would be greater than or equal to a second (or less than
or equal to a negative second).
It holds hnsecs internally, but you can create it using either milliseconds,
microseconds, or hnsecs. What it does is allow for a simple way to set or
adjust the fractional seconds portion of a Duration or a
std.datetime.SysTime without having to worry about whether you're
dealing with milliseconds, microseconds, or hnsecs.
FracSec's functions which take time unit strings do accept
"nsecs", but because the resolution of Duration and
std.datetime.SysTime is hnsecs, you don't actually get precision higher
than hnsecs. "nsecs" is accepted merely for convenience. Any values
given as nsecs will be converted to hnsecs using convert (which uses
truncating division when converting to smaller units).
- static pure nothrow @property @safe FracSec zero();
- A FracSec of 0. It's shorter than doing something like FracSec.from!"msecs"(0) and more explicit than FracSec.init.
- pure @safe FracSec from(string units)(long
*value*) if (units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs"); - Create a FracSec from the given units ("msecs", "usecs",
or "hnsecs").
**Parameters:**units The units to create a FracSec from. long value The number of the given units passed the second. **Throws:**

TimeException if the given value would result in a FracSec greater than or equal to 1 second or less than or equal to -1 seconds. - const pure nothrow @safe FracSec opUnary(string op)() if (op == "-");
- Returns the negation of this FracSec.
- const pure nothrow @property @safe int msecs();
- The value of this FracSec as milliseconds.
- pure @property @safe void msecs(int
*milliseconds*); - The value of this FracSec as
*milliseconds*.**Parameters:**int *milliseconds*The number of *milliseconds*passed the second.**Throws:**

TimeException if the given value is not less than 1 second and greater than a -1 seconds. - const pure nothrow @property @safe int usecs();
- The value of this FracSec as microseconds.
- pure @property @safe void usecs(int
*microseconds*); - The value of this FracSec as
*microseconds*.**Parameters:**int *microseconds*The number of *microseconds*passed the second.**Throws:**

TimeException if the given value is not less than 1 second and greater than a -1 seconds. - const pure nothrow @property @safe int hnsecs();
- The value of this FracSec as hnsecs.
- pure @property @safe void hnsecs(int hnsecs);
- The value of this FracSec as hnsecs.
**Parameters:**int hnsecs The number of hnsecs passed the second. **Throws:**

TimeException if the given value is not less than 1 second and greater than a -1 seconds. - const pure nothrow @property @safe int nsecs();
- The value of this FracSec as nsecs. Note that this does not give you any greater precision than getting the value of this FracSec as hnsecs.
- pure @property @safe void nsecs(long nsecs);
- The value of this FracSec as nsecs.
Note that this does not give you any greater precision
than setting the value of this FracSec as hnsecs.
**Parameters:**long nsecs The number of nsecs passed the second. **Throws:**

TimeException if the given value is not less than 1 second and greater than a -1 seconds. - const pure nothrow @safe string toString();
- Converts this TickDuration to a string.

- class TimeException:
__object.Exception__; - Exception type used by core.time.
- pure nothrow @safe this(string
*msg*, string*file*= __FILE__, size_t*line*= __LINE__, Throwable*next*= null); **Parameters:**string *msg*The message for the exception. string *file*The *file*where the exception occurred.size_t *line*The *line*number where the exception occurred.Throwable *next*The previous exception in the chain of exceptions, if any. - pure nothrow @safe this(string
*msg*, Throwable*next*, string*file*= __FILE__, size_t*line*= __LINE__); **Parameters:**string *msg*The message for the exception. Throwable *next*The previous exception in the chain of exceptions. string *file*The *file*where the exception occurred.size_t *line*The *line*number where the exception occurred.

- pure nothrow @safe this(string
- pure nothrow @safe Duration abs(Duration
*duration*);

pure nothrow @safe TickDuration abs(TickDuration*duration*); - Returns the absolute value of a
*duration*.