core.time

Модуль, содержащий основные функции работы со временем, такие как Duration (представляющая продолжительность времени) или MonoTime (представляющая отметку времени монотонных часов системы).

Различные функции принимают строку (или строки) для представления единицы измерения времени (например, convert!("days", "hours")(numDays)). Допустимые строки для использования с такими функциями — "years", "months", "weeks", "days", "hours", "minutes", "seconds", "msecs" (миллисекунды), "usecs" (микросекунды), "hnsecs" (гекто-наносекунды — т. е. 100 нс) или их подмножество. Есть несколько функций, которые также допускают "nsecs", но в действительности очень мало чего имеет точность больше, чем hnsecs.

Лицензия:

Лицензия Boost 1.0.

Авторы:

Jonathan M Davis и Kato Shoichi

Исходный код

core/time.d

перечисление ClockType: int;

Какой тип часов использовать с MonoTime / MonoTimeImpl или std.datetime.Clock.currTime. По умолчанию они равны ClockType.normal, и большинству программ не нужно иметь дело с другими.

Другие ClockType предоставлены для того, чтобы другие часы, предоставляемые базовыми вызовами C и системы, можно было использовать с MonoTimeImpl или std.datetime.Clock.currTime без прямого использования API C.

В случае монотонного времени MonoTimeImpl шаблонный по ClockType, тогда как с std.datetime.Clock.currTime, это аргумент во время выполнения, так как в случае монотонного времени тип часов влияет на разрешение объекта MonoTimeImpl, тогда как с std.datetime.SysTime, его разрешение всегда составляет гекто-наносекунды независимо от источника времени.

ClockType.normal, ClockType.coarse, и ClockType.precise работают как с Clock.currTime , так и с MonoTimeImpl. ClockType.second работает только с Clock.currTime. Остальные работают только с MonoTimeImpl.

normal

Использовать стандартные часы.

bootTime

Только Linux,OpenBSD

Использует CLOCK_BOOTTIME.

coarse

Использовать грубые часы, а не стандартные (например, в Linux это CLOCK_REALTIME_COARSE вместо CLOCK_REALTIME для clock_gettime , если функция использует реальное время). Как правило, получение времени с помощью грубых часов быстрее, чем со стандартными часами, но оно менее точно (например, 1 мс вместо 1 мкс или 1 нс). Однако гарантируется, что оно по-прежнему будет иметь точность до секунды (но не так высокую, как с ClockType.normal).

На системах, которые не поддерживают грубые часы, MonoTimeImpl!(ClockType.coarse) внутренне будет использовать те же часы, что и Monotime , а Clock.currTime!(ClockType.coarse) будет использовать те же часы, что и Clock.currTime. Это потому, что грубые часы делают то же, что и обычные часы (только с меньшей точностью), в то время как некоторые другие типы часов (например, ClockType.processCPUTime) означают нечто принципиально иное. Поэтому обработка их как ClockType.normal на системах, где они не поддерживаются нативно, даст вводящие в заблуждение результаты.

Большинству программ не следует использовать грубые часы, именно потому, что они менее точные, и большинству программ не нужно получать время достаточно часто, чтобы об этом заботиться, но для тех редких программ, которым необходимо получать время очень часто (например, сотни тысяч раз в секунду), но не требуется высокая точность, грубые часы могут быть подходящими.

В настоящее время только Linux и FreeBSD/DragonFlyBSD поддерживают грубые часы, а на других платформах они обрабатываются как ClockType.normal.

precise

Использует более точные часы, чем стандартные (которые уже очень точные), но получение времени занимает больше времени. Аналогично ClockType.coarse, если он используется на системе, которая не поддерживает более точные часы, чем стандартные, он обрабатывается как эквивалент ClockType.normal.

В настоящее время только FreeBSD/DragonFlyBSD поддерживают более точные часы, где они используют CLOCK_MONOTONIC_PRECISE для монотонного времени и CLOCK_REALTIME_PRECISE для времени реальных часов.

processCPUTime

Только Linux,OpenBSD,Solaris

Использует CLOCK_PROCESS_CPUTIME_ID.

raw

Только Linux

Использует CLOCK_MONOTONIC_RAW.

second

Использует часы с точностью до одной секунды (в отличие от грубых часов, которые имеют точность до долей секунды, как и стандартные).

FreeBSD/DragonFlyBSD — единственные системы, в которых специально настроенны часы для этого (они имеют CLOCK_SECOND для использования с clock_gettime, что использует кешированное значение в ядре), но на других системах будет использована самая быстрая доступная функция, а полученное SysTime будет округлено вниз до секунды, если часы давали время с большей точностью. Поэтому гарантируется, что время будет предоставлено с точностью до секунды, и, вероятно, это будет быстрее, чем ClockType.normal, так как на системах обычно есть несколько вариантов получения времени с низким разрешением, которые, как правило, быстрее, чем получение времени с высоким разрешением.

Поэтому основное различие между ClockType.coarse и ClockType.second заключается в том, что ClockType.coarse жертвует некоторой точностью ради скорости, но по-прежнему достаточно точен, тогда как ClockType.second пытается быть максимально быстрым в ущерб любой точности до десятых долей секунды.

threadCPUTime

Только Linux,OpenBSD,Solaris

Использует CLOCK_THREAD_CPUTIME_ID.

uptime

Только DragonFlyBSD,FreeBSD,OpenBSD

Использует CLOCK_UPTIME.

uptimeCoarse

Только FreeBSD

Использует CLOCK_UPTIME_FAST.

uptimePrecise

Только FreeBSD

Использует CLOCK_UPTIME_PRECISE.

структура Duration;

Представляет продолжительность времени до недели (внутренне хранится как hnsecs). (например, 22 дня или 700 секунд).

Используется для представления продолжительности времени, например, для определения времени сна с помощью core.thread.Thread.sleep.

В std.datetime также используется в качестве результата различных арифметических операций над временными точками.

Используйте функцию dur или один из ее негенерализованных псевдонимов для создания Duration.

Невозможно создать Duration для месяцев или лет, потому что переменное количество дней в месяце или году делает невозможным преобразование между месяцами или годами и меньшими единицами без указания конкретной даты. Поэтому ничего не использует Duration при работе с месяцами или годами. Вместо этого определены функции, специфичные для месяцев и лет. Например, у std.datetime.Date есть add!"years" и add!"months" для добавления лет и месяцев, а не для создания Duration для лет или месяцев и добавления этого к std.datetime.Date. Но Duration используется при работе со временами, не превышающими неделю.

Примеры:

import std.datetime;

assert(dur!"days"(12) == dur!"hnsecs"(10_368_000_000_000L));
assert(dur!"hnsecs"(27) == dur!"hnsecs"(27));
assert(std.datetime.Date(2010, 9, 7) + dur!"days"(5) ==
       std.datetime.Date(2010, 9, 12));

assert(days(-12) == dur!"hnsecs"(-10_368_000_000_000L));
assert(hnsecs(-27) == dur!"hnsecs"(-27));
assert(std.datetime.Date(2010, 9, 7) - std.datetime.Date(2010, 10, 3) ==
       days(-26));

Примеры:

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 @nogc @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 @nogc @property @safe Duration max();

Largest Duration possible.

static pure nothrow @nogc @property @safe Duration min();

Most negative Duration possible.

const pure nothrow @nogc @safe int opCmp(Duration rhs);

Compares this Duration with the given Duration.

Returns:

this < rhs	< 0
this == rhs	0
this > rhs	> 0

const nothrow @nogc Duration opBinary(string op, D)(D rhs)
Constraints: if ((op == "+" || op == "-" || op == "%") && is(immutable(D) == immutable(Duration)) || (op == "+" || op == "-") && is(immutable(D) == immutable(TickDuration)));

Adds, subtracts or calculates the modulo of two durations.

The legal types of arithmetic for Duration using this operator are

Duration	+	Duration	-->	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 nothrow @nogc Duration opBinaryRight(string op, D)(D lhs)
Constraints: if ((op == "+" || op == "-") && is(immutable(D) == immutable(TickDuration)));

Adds or subtracts two durations.

The legal types of arithmetic for Duration using this operator are

TickDuration	+	Duration	-->	Duration
TickDuration	-	Duration	-->	Duration

Parameters:

D lhs

The TickDuration to add to this Duration or to subtract this Duration from.

nothrow @nogc ref Duration opOpAssign(string op, D)(scope const D rhs)
Constraints: if ((op == "+" || op == "-" || op == "%") && is(immutable(D) == immutable(Duration)) || (op == "+" || op == "-") && is(immutable(D) == immutable(TickDuration)));

Adds, subtracts or calculates the modulo of 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	%	Duration	-->	Duration
Duration	+	TickDuration	-->	Duration
Duration	-	TickDuration	-->	Duration

Parameters:

D rhs

The duration to add to or subtract from this Duration.

const nothrow @nogc Duration opBinary(string op)(long value)
Constraints: if (op == "*" || op == "/");

Multiplies or divides the duration by an integer value.

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.

nothrow @nogc ref Duration opOpAssign(string op)(long value)
Constraints: if (op == "*" || op == "/");

Multiplies/Divides the duration by an integer value as well as assigning the result to this Duration.

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/divide this Duration by.

const nothrow @nogc long opBinary(string op)(Duration rhs)
Constraints: if (op == "/");

Divides two durations.

The legal types of arithmetic for Duration using this operator are

Duration

/

Duration

-->

long

Parameters:

Duration rhs

The duration to divide this Duration by.

const nothrow @nogc Duration opBinaryRight(string op)(long value)
Constraints: if (op == "*");

Multiplies an integral value and a Duration.

The legal types of arithmetic for Duration using this operator overload are

long

*

Duration

-->

Duration

Parameters:

long value

The number of units to multiply this Duration by.

const nothrow @nogc Duration opUnary(string op)()
Constraints: if (op == "-");

Returns the negation of this Duration.

const nothrow @nogc TickDuration opCast(T)()
Constraints: if (is(immutable(T) == immutable(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()

const nothrow @nogc bool opCast(T : bool)();

Allow Duration to be used as a boolean.

Returns:

true if this duration is non-zero.

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 nothrow @nogc void split(Args...)(out Args args)
Constraints: if (units.length != 0 && (args.length == units.length) && allAreMutableIntegralTypes!Args);

const nothrow @nogc auto split();

Ditto

const nothrow @nogc @property long total(string units)()
Constraints: 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();

Преобразует этот Duration в string.

Строка предназначена для чтения человеком, а не для разбора машиной (например, наличие 's' в конце имени единицы обычно зависит от того, является ли оно множественным, и пустые единицы не включаются, если Duration не zero). Любой код, которому нужен определённый формат строки, должен использовать total или split для получения необходимых единиц для создания желаемого формата строки и создания самой строки.

Формат, возвращаемый методом toString, может или не может изменяться в будущем.

Примеры:

assert(Duration.zero.toString() == "0 hnsecs");
assert(weeks(5).toString() == "5 weeks");
assert(days(2).toString() == "2 days");
assert(hours(1).toString() == "1 hour");
assert(minutes(19).toString() == "19 minutes");
assert(seconds(42).toString() == "42 secs");
assert(msecs(42).toString() == "42 ms");
assert(usecs(27).toString() == "27 μs");
assert(hnsecs(5).toString() == "5 hnsecs");

assert(seconds(121).toString() == "2 minutes and 1 sec");
assert((minutes(5) + seconds(3) + usecs(4)).toString() ==
       "5 minutes, 3 secs, and 4 μs");

assert(seconds(-42).toString() == "-42 secs");
assert(usecs(-5239492).toString() == "-5 secs, -239 ms, and -492 μs");

const pure nothrow @nogc @property @safe bool isNegative();

Возвращает, является ли этот Duration отрицательным.

pure nothrow @nogc @safe T to(string units, T, D)(D td)
Constraints: if (is(immutable(D) == immutable(TickDuration)) && (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs"));

Преобразует TickDuration в заданные единицы как целое или число с плавающей точкой.

Параметры:

units	Единицы измерения для преобразования. Принимает значения "seconds" и меньшие.
T	Тип для преобразования (целый тип или тип с плавающей точкой).
D td	TickDuration для преобразования

Примеры:

auto t = TickDuration.from!"seconds"(1000);

long tl = to!("seconds",long)(t);
assert(tl == 1000);

import core.stdc.math : fabs;
double td = to!("seconds",double)(t);
assert(fabs(td - 1000) < 0.001);

pure nothrow @nogc @safe Duration dur(string units)(long length)
Constraints: 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;

Эти функции позволяют создать Duration из заданных единиц измерения времени с заданной длительностью.

Вы можете использовать общую функцию dur и указать единицы измерения как string или использовать именованные псевдонимы.

Возможные значения для единиц измерения: "weeks", "days", "hours", "minutes", "seconds", "msecs" (миллисекунды), "usecs", (микросекунды), "hnsecs" (гекто-наносекунды, т.е. 100 нс) и "nsecs".

Параметры:

units	Единицы измерения времени Duration (например, "days").
long length	Количество единиц в Duration.

Примеры:

// 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);

alias MonoTime = MonoTimeImpl!ClockType.normal.MonoTimeImpl;

Псевдоним для MonoTimeImpl с ClockType.normal. Это то, что должны использовать большинство программ. Это также то, что большая часть MonoTimeImpl использует в своей документации (особенно в примерах), потому что это будет использоваться в большинстве кодов.

struct MonoTimeImpl(ClockType clockType);

Представляет собой метку времени монотонных часов системы.

Монотонные часы — это часы, которые всегда идут вперёд и никогда не идут назад, в отличие от системного времени (представленного в std.datetime.SysTime). Системное время может быть скорректировано пользователем или самой системой с помощью таких служб, как NTP, поэтому использование системного времени для измерения времени ненадежно. Таймеры, использующие системное время, могут легко оказаться никогда не срабатывающими из-за изменений, внесенных в системное время, или иначе ожидать другого промежутка времени, чем тот, который задан программистом. Однако, поскольку монотонные часы всегда увеличиваются с постоянной скоростью и не зависят от корректировок системного времени, они идеально подходят для использования с таймерами или любым приложением, требующим высокой точности измерения времени.

Таким образом, MonoTime следует использовать для любых задач, связанных с таймерами и измерением времени, а std.datetime.SysTime следует использовать, когда требуется системное время.

Монотонные часы не имеют отношения к системному времени. Вместо этого они хранят время как количество тиков часов, прошедших с момента запуска часов (обычно при запуске системы). Таким образом, чтобы определить, сколько времени прошло между двумя моментами времени, из одного монотонного времени вычитается другое, чтобы определить количество тиков, произошедших между двумя моментами времени, и эти тики делятся на количество тиков, происходящих каждую секунду (как представлено в MonoTime.ticksPerSecond), чтобы получить значительный период времени. Обычно MonoTime выполняет эти вычисления для программиста, но свойства ticks и ticksPerSecond предоставляются для тех, кому нужен прямой доступ к системным тикам. Обычный способ использования MonoTime:

    MonoTime before = MonoTime.currTime;
    // do stuff...
    MonoTime after = MonoTime.currTime;
    Duration timeElapsed = after - before;

MonoTime — это псевдоним для MonoTimeImpl!(ClockType.normal) и это то, что должны использовать большинство программ для монотонных часов, поэтому это используется в большей части документации MonoTimeImpl. Но MonoTimeImpl может быть создан с другими типами часов для тех редких программ, которым это необходимо.

См. также:

ClockType

static nothrow @nogc @property @trusted MonoTimeImpl currTime();

Текущее время монотонных часов системы. Это не имеет отношения к системному времени, так как системное время может быть скорректировано (например, NTP), в то время как монотонные часы всегда идут вперёд. Источник монотонного времени зависит от системы.

В Windows используется QueryPerformanceCounter. В Mac OS X используется mach_absolute_time, а в других системах POSIX используется clock_gettime.

Предупреждение: В некоторых системах монотонные часы могут перестать отсчитывать время, когда компьютер переходит в спящий режим или в режим гибернации. Таким образом, монотонные часы могут указывать меньшее время, чем фактически прошло, если это произойдёт. Известно, что это происходит в Mac OS X. Не проверялось, происходит ли это в Windows или Linux.

MonoTimeImpl zero();

Значение MonoTime 0 тиков. Оно предоставлено для согласованности с Duration.zero, и оно более явное, чем MonoTime.init.

MonoTimeImpl max();

Максимальное возможное значение MonoTime.

MonoTimeImpl min();

Наименьшее возможное отрицательное значение MonoTime.

const pure nothrow @nogc int opCmp(MonoTimeImpl rhs);

Сравнивает текущее MonoTime с заданным MonoTime.

Возвращаемое значение:

this < rhs	< 0
this == rhs	0
this > rhs	> 0

const pure nothrow @nogc Duration opBinary(string op)(MonoTimeImpl rhs)
Constraints: if (op == "-");

Вычитание двух MonoTime возвращает Duration, представляющее количество времени, прошедшего между ними.

Основной способ, которым программы должны измерять, сколько времени что-то занимает, это сделать

MonoTime before = MonoTime.currTime;
// do stuff
MonoTime after = MonoTime.currTime;

// How long it took.
Duration timeElapsed = after - before;

или использовать обёртку (например, тип секундомера), которая это делает.

Предупреждение: Поскольку Duration в hnsecs, а MonoTime в системных тиках, обычно происходит, что это утверждение не выполняется

auto before = MonoTime.currTime;
// do stuff
auto after = MonoTime.currTime;
auto timeElapsed = after - before;
assert(before + timeElapsed == after);

Это обычно нормально, и по своему определению преобразование из системных тиков в любой тип секунд (hnsecs, nsecs и т.д.) будет вводить ошибки округления, но если код должен избежать каких-либо небольших ошибок округления, введённых преобразованием, то он должен использовать свойство MonoTime ticks и сохранять все вычисления в тиках, а не использовать Duration.

const pure nothrow @nogc MonoTimeImpl opBinary(string op)(Duration rhs)
Constraints: if (op == "+" || op == "-");

pure nothrow @nogc ref MonoTimeImpl opOpAssign(string op)(Duration rhs)
Constraints: if (op == "+" || op == "-");

Добавление или вычитание Duration к/из MonoTime приводит к MonoTime, скорректированному на эту величину.

const pure nothrow @nogc @property long ticks();

Количество тиков в монотонном времени.

Большинство программ не должны использовать это напрямую, но оно предоставляется для тех немногих программ, которым это нужно.

Основные причины, по которым программе может потребоваться использовать тики напрямую, это если системные часы имеют более высокую точность, чем hnsecs, и программе требуется эта более высокая точность, или если программе требуется избежать ошибок округления, возникающих при преобразовании в hnsecs.

static pure nothrow @nogc @property long ticksPerSecond();

Количество тиков в MonoTime за секунду — т.е. разрешение или частота монотонных часов системы.

Например, если системные часы имеют разрешение микросекунды, то ticksPerSecond будет 1_000_000.

const pure nothrow string toString();

pure nothrow @nogc @safe long convClockFreq(long ticks, long srcTicksPerSecond, long dstTicksPerSecond);

Преобразует заданное время из одной частоты/разрешения таймера в другую.

См. также:

ticksToNSecs

Примеры:

// one tick is one second -> one tick is a hecto-nanosecond
assert(convClockFreq(45, 1, 10_000_000) == 450_000_000);

// one tick is one microsecond -> one tick is a millisecond
assert(convClockFreq(9029, 1_000_000, 1_000) == 9);

// one tick is 1/3_515_654 of a second -> 1/1_001_010 of a second
assert(convClockFreq(912_319, 3_515_654, 1_001_010) == 259_764);

// one tick is 1/MonoTime.ticksPerSecond -> one tick is a nanosecond
// Equivalent to ticksToNSecs
auto nsecs = convClockFreq(1982, MonoTime.ticksPerSecond, 1_000_000_000);

pure nothrow @nogc @safe long ticksToNSecs(long ticks);

Обёртка над convClockFreq, которая преобразует тики с частотой MonoTime.ticksPerSecond в наносекунды.

В основном используется, когда MonoTime.ticksPerSecond превышает разрешение в гекто-наносекунды, и приложение нуждается в большей точности, чем гекто-наносекунды.

См. также:

convClockFreq

Примеры:

auto before = MonoTime.currTime;
// do stuff
auto after = MonoTime.currTime;
auto diffInTicks = after.ticks - before.ticks;
auto diffInNSecs = ticksToNSecs(diffInTicks);
assert(diffInNSecs == convClockFreq(diffInTicks, MonoTime.ticksPerSecond, 1_000_000_000));

pure nothrow @nogc @safe long nsecsToTicks(long ticks);

Обратное преобразование к ticksToNSecs.

struct TickDuration;

Предупреждение: TickDuration будет устаревать в ближайшее время (после того, как все её использования в Phobos будут устаревшими). Пожалуйста, используйте MonoTime в случаях, когда требуется монотонная метка времени, и Duration для случаев, когда нужна продолжительность, а не TickDuration. Было решено, что TickDuration слишком запутан (например, объединяет монотонную метку времени и продолжительность в монотонных тиках таймера) и что наличие нескольких типов продолжительности слишком неудобно и запутанно.

Представляет длительность времени в тиках системного таймера.

Тики системного таймера — это тики системного таймера с наивысшей точностью, предоставляемой системой.

static immutable long ticksPerSec;

Количество тиков системных часов за одну секунду.

Если ticksPerSec равно 0, значит, TickDuration не удалось получить значение ticksPerSec на текущей системе, и TickDuration не будет работать. Хотя это весьма необычно.

static immutable TickDuration appOrigin;

Отметка времени системных часов (как TickDuration) при запуске приложения.

static pure nothrow @nogc @property @safe TickDuration zero();

Это то же самое, что и TickDuration(0), но предоставлено для согласованности с Duration, который предоставляет свойство zero.

static pure nothrow @nogc @property @safe TickDuration max();

Максимально возможное значение TickDuration.

static pure nothrow @nogc @property @safe TickDuration min();

Наименьшее отрицательное значение TickDuration.

long length;

Количество тиков системных часов в данном TickDuration.

Вы можете преобразовать это значение length в количество секунд, разделив его на ticksPerSec (или используя соответствующую функцию свойства).

const pure nothrow @nogc @property @safe long seconds();

Возвращает общее количество секунд в данном TickDuration.

const pure nothrow @nogc @property @safe long msecs();

Возвращает общее количество миллисекунд в данном TickDuration.

const pure nothrow @nogc @property @safe long usecs();

Возвращает общее количество микросекунд в данном TickDuration.

const pure nothrow @nogc @property @safe long hnsecs();

Возвращает общее количество гекто-наносекунд в данном TickDuration.

const pure nothrow @nogc @property @safe long nsecs();

Возвращает общее количество наносекунд в данном TickDuration.

pure nothrow @nogc @safe TickDuration from(string units)(long length)
Constraints: if (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

Позволяет создать TickDuration из заданных единиц времени с заданной длительностью.

Параметры:

units	Единицы времени TickDuration (например, "msecs").
long length	Количество единиц времени в TickDuration.

const pure nothrow @nogc @safe Duration opCast(T)()
Constraints: if (is(immutable(T) == immutable(Duration)));

Возвращает Duration с тем же количеством гекто-наносекунд, что и у данного TickDuration. Обратите внимание, что стандартный способ преобразования между TickDuration и Duration использует std.conv.to, например: tickDuration.to!Duration()

pure nothrow @nogc ref @safe TickDuration opOpAssign(string op)(TickDuration rhs)
Constraints: if (op == "+" || op == "-");

Складывает или вычитает два TickDuration и присваивает результат этому TickDuration.

Допустимые типы арифметических операций для TickDuration с использованием этого оператора:

TickDuration	+=	TickDuration	-->	TickDuration
TickDuration	-=	TickDuration	-->	TickDuration

Параметры:

TickDuration rhs

TickDuration для сложения или вычитания из данного TickDuration.

const pure nothrow @nogc @safe TickDuration opBinary(string op)(TickDuration rhs)
Constraints: if (op == "+" || op == "-");

Складывает или вычитает два TickDuration.

Допустимые типы арифметических операций для TickDuration с использованием этого оператора:

TickDuration	+	TickDuration	-->	TickDuration
TickDuration	-	TickDuration	-->	TickDuration

Параметры:

TickDuration rhs

TickDuration для сложения или вычитания из данного TickDuration.

const pure nothrow @nogc @safe TickDuration opUnary(string op)()
Constraints: if (op == "-");

Возвращает отрицание данного TickDuration.

const pure nothrow @nogc @safe int opCmp(TickDuration rhs);

Перегрузка операторов "<, >, <=, >="

pure nothrow @nogc @safe void opOpAssign(string op, T)(T value)
Constraints: if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T)));

Допустимые типы арифметических операций для TickDuration с использованием этой перегрузки оператора:

TickDuration	*	long	-->	TickDuration
TickDuration	*	с плавающей точкой	-->	TickDuration

Параметры:

T value

Значение для умножения с этой длительностью.

pure @safe void opOpAssign(string op, T)(T value)
Constraints: if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T)));

Допустимые типы арифметических операций для TickDuration с использованием этой перегрузки оператора:

TickDuration	/	long	-->	TickDuration
TickDuration	/	с плавающей точкой	-->	TickDuration

Параметры:

T value

Значение для деления от этой длительности.

Исключения:

TimeException если происходит попытка деления на 0.

const pure nothrow @nogc @safe TickDuration opBinary(string op, T)(T value)
Constraints: if (op == "*" && (__traits(isIntegral, T) || __traits(isFloating, T)));

Допустимые типы арифметических операций для TickDuration с использованием этой перегрузки оператора:

TickDuration	*	long	-->	TickDuration
TickDuration	*	с плавающей точкой	-->	TickDuration

Параметры:

T value

Значение для умножения с этой длительностью.

const pure @safe TickDuration opBinary(string op, T)(T value)
Constraints: if (op == "/" && (__traits(isIntegral, T) || __traits(isFloating, T)));

Допустимые типы арифметических операций для TickDuration с использованием этой перегрузки оператора:

TickDuration	/	long	-->	TickDuration
TickDuration	/	с плавающей точкой	-->	TickDuration

Параметры:

T value

Значение для деления от этой длительности.

Исключения:

TimeException если происходит попытка деления на 0.

pure nothrow @nogc @safe this(long ticks);

Параметры:

long ticks

Количество тиков в TickDuration.

static nothrow @nogc @property @trusted TickDuration currSystemTick();

Текущий тик системы. Количество тиков в секунду варьируется от системы к системе. currSystemTick использует монотонные часы, поэтому предназначен для точного измерения времени, сравнивая значения относительного времени, а не для получения текущего времени системы.

В Windows используется QueryPerformanceCounter. В Mac OS X используется mach_absolute_time, а в других системах Posix используется clock_gettime. Если mach_absolute_time или clock_gettime недоступны, тогда системы Posix используют gettimeofday (решение принимается во время компиляции TickDuration), что, к сожалению, не является монотонным, но если mach_absolute_time и clock_gettime недоступны, то gettimeofday - лучшее, что есть.

Предупреждение: На некоторых системах монотонные часы могут прекратить отсчёт при переходе компьютера в спящий режим или гибернацию. Следовательно, монотонные часы могут быть неточны, если это произошло. Известно, что это происходит в Mac OS X. Не было проверено, происходит ли это в Windows или Linux.

Исключения:

TimeException если не удалось получить время.

pure nothrow @nogc @safe long convert(string from, string to)(long value)
Constraints: 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"));

Общий способ преобразования между двумя единицами времени. Преобразования в меньшие единицы используют усечение при делении. Годы и месяцы могут быть преобразованы друг в друга, мелкие единицы могут быть преобразованы друг в друга, но годы и месяцы не могут быть преобразованы в меньшие единицы (из-за переменного числа дней в месяце или году).

Параметры:

from	Единицы времени, из которых следует выполнить преобразование.
to	Единицы времени, в которые следует выполнить преобразование.
long value	Значение для преобразования.

Примеры:

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);

class TimeException: object.Exception;

Тип исключения, используемый в core.time.

pure nothrow @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);

Параметры:

string msg	Сообщение об исключении.
string file	Файл, в котором произошло исключение.
size_t line	Номер строки, на которой произошло исключение.
Throwable next	Предыдущее исключение в цепочке исключений, если таковое имеется.

pure nothrow @safe this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__);

Параметры:

string msg	Сообщение об исключении.
Throwable next	Предыдущее исключение в цепочке исключений.
string file	Файл, в котором произошло исключение.
size_t line	Номер строки, на которой произошло исключение.

pure nothrow @nogc @safe Duration abs(Duration duration);

pure nothrow @nogc @safe TickDuration abs(TickDuration duration);

Возвращает абсолютное значение продолжительности.