core.time

enum ClockType: int;

どんな時計を使うか? MonoTime/ MonoTimeImplまたは std.datetime.Clock.currTime.これらはデフォルトでClockType.normal 、 に設定されており、ほとんどのプログラムではそれ以外を扱う必要はない。

その他のClockTypeは、C言語システム・コールが提供する他のクロックを使用できるように提供されている。 が提供する他のクロックを使用できるように提供されている。 MonoTimeImplまたは std.datetime.Clock.currTime Cの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 の代わりになる)。一般的に 一般的に、通常のクロックよりも粗いクロックの方が時刻の取得が速い。 しかし、精度は落ちる(例えば、1usecや1nsecの代わりに1msec)。 しかし、それでも秒以下の精度は保証されている。 (ClockType.normal ほどではない)。

より粗いクロックをサポートしないシステムでは、"@system"は内部的に同じクロックを使用する、 MonoTimeImpl!(ClockType.coarse) は内部的に と同じクロック MonoTime Clock.currTime!(ClockType.coarse) と同じクロックを使用する。 はClock.currTime と同じクロックを使用する。これは、粗い これは、粗いクロックが(精度が低いだけで)通常のクロックと同じことを行っているからである。 他のクロック型(例えば )は、通常のクロックと同じことを行っている。 (例えばClockType.processCPUTime)は根本的に異なることを意味する。 を意味する。そのため、"@system"がネイティブでサポートされていないシステムでは、それらをClockType.normal 。 として扱うと、誤解を招く結果になる。

ほとんどのプログラムは粗いクロックを使うべきではない。 ほとんどのプログラムは粗いクロックを使うべきではない。 しかし、非常に頻繁に(例えば数百回)時刻を取得する必要があるような稀なプログラムでは、粗いクロックを使うべきでない。 しかし、非常に頻繁に(例えば1秒間に何十万回も)時刻を取得する必要があるが、高精度にこだわらない稀なプログラムには、粗いクロックを使う必要はない。 しかし、非常に頻繁に(例えば数十万秒)時間を取得する必要があるが、高精度にこだわらない稀なプログラムには、粗いクロックが適切かもしれない。

現在、粗いクロックをサポートしているのは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 は秒単位で切り捨てられる。 秒単位で切り捨てられる。つまり が1秒の精度で与えられることが保証される。 ClockType.normal よりも速くなる可能性が高い。 低解像度で時刻を取得するには、システム上にいくつかのオプションがあり、それらは時刻を取得するよりも速くなる傾向があるからだ。 というのも、低解像度で時刻を得るには、システム上にいくつかのオプションがあり、それらは高解像度で時刻を得るよりも速い傾向があるからだ。

つまり、ClockType.coarse と ClockType.second との主な違いは、ClockType.coarse は速度を得るために精度を多少犠牲にしているが、それでもかなり正確だということだ。 速度を得るために精度を犠牲にしているが、それでもかなり正確である。 ClockType.second は秒以下の精度を犠牲にしてでも可能な限り速くしようとする。 秒以下の精度を犠牲にして、可能な限り速くしようとする。

threadCPUTime

Linux、OpenBSD、Solarisのみ

使用CLOCK_THREAD_CPUTIME_ID.

uptime

DragonFlyBSD,FreeBSD,OpenBSD-Onlyを使用する。

CLOCK_UPTIME を使用する。

uptimeCoarse

FreeBSDのみ

CLOCK_UPTIME_FAST を使用。

uptimePrecise

FreeBSD のみ

CLOCK_UPTIME_PRECISE を使用する。

struct Duration;

数週間以下の期間を表す (内部的には hnsecs として保持される)。 (例: 22 日または 700 秒)。

これは、次のような時間の長さを表すときに使われる。 で寝る。 core.thread.Thread.sleep.

また、std.datetimeでは、時間ポイントに対するさまざまな算術演算の結果としても使われる。 として使われる。

この dur関数またはその非ジェネリック・エイリアスを用いて Durations.

月や年の期間を作成することはできない。 というのも、月や年の日数は可変であるため、特定の日付なしに月や年とそれ以下の単位を変換することは不可能だからである。 というのも、月や年の日数が可変であるため、特定の日付なしに月や年とそれより小さい単位との間で変換することができないからである。だから Durationを使うことはできない。そうではない、 関数が定義されている。例えば std.datetime.Dateには、年や月を足すためのadd!"years" とadd!"months" がある。 年や月のデュレーションを作成し、それを に追加する。 std.datetime.Date.しかし、Durationは を使う。

Examples:

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

Examples:

import core.time;

// durテンプレートを使用する
auto numDays = dur!"days"(12);

// days関数を使用する
numDays = days(12);

// またはUFCS構文を使う
numDays = 12.days;

auto myTime = 100.msecs + 20_000.usecs + 30_000.hnsecs;
assert(myTime == 123.msecs);

const scope void toString(SinkT)(scope SinkT sink);

Duration をstring に変換する。

この文字列は人間が読めるものであり、機械が解析できるものではない(例えば、ユニット名の末尾に があるかどうかは、通常、ユニット名によって異なる)。 ユニット名の末尾に's' があるかどうかは、通常、それが複数形かどうかによって決まる。 が複数形であるかどうかに依存する。 zero でない限り、空のユニットは含まれない。)特定の文字列フォーマットが必要なコードは 特定の文字列書式を必要とするコードは、total またはsplit を使用して、希望の文字列書式を作成するために必要な単位を取得し、文字列自体を作成する。 を使用して、希望する文字列フォーマットを作成するために必要な単位を取得し、文字列自体を作成する必要がある。

toStringが返す書式は、将来変わるかもしれないし、変わらないかもしれない。

Parameters:

SinkT sink

シンクオブジェクトは、デリゲートまたはアグリゲートであることが期待される。 を引数として受け取るopCall 。scope const(char)[] を引数として受け取る。

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

0 のDuration である。 dur!"seconds"(0) のようにするよりも短く、Duration.init よりも明示的である。

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

Duration 可能な最大値。

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

可能な限り最大の負のDuration 。

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

このDuration と与えられたDuration を比較する。

Returns:

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

const nothrow @nogc Duration opBinary(string op)(const Duration rhs)
if (op == "+" || op == "-" || op == "%");

2つの持続時間のモジュロを加算、減算、または計算する。

この演算子を使用したDuration の算術演算は以下の通りである。

持続時間	+	期間	-->	デュレーション
デュレーション	-	デュレーション	-->	デュレーション
持続時間	%	期間	-->	デュレーション

Parameters:

Duration rhs

このDuration に加算または減算する継続時間。

const nothrow @nogc Duration opBinaryRight(string op, D)(D lhs)
if ((op == "+" || op == "-") && is(immutable(D) == immutable(TickDuration)));

TickDurationは非推奨

2つの継続時間を加算または減算する。

この演算子を使用したDuration の算術演算の有効な型は以下の通りである。

継続時間	+	継続時間	-->	継続時間
継続時間	-	継続時間	-->	継続時間

Parameters:

D lhs

このDuration に足す、またはこの から引くTickDuration 。 Duration から引く。

nothrow @nogc ref Duration opOpAssign(string op)(const Duration rhs)
if (op == "+" || op == "-" || op == "%");

加算、減算、または2つの持続時間のモジュロの計算を行う。 結果をこのDuration に代入する。

この演算子を使用するDuration の算術演算の有効な型は以下のとおりである。

持続時間	+	期間	-->	デュレーション
デュレーション	-	デュレーション	-->	デュレーション
持続時間	%	期間	-->	デュレーション

Parameters:

Duration rhs

Duration に加算または減算する持続時間。

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

持続時間を整数値で乗算または除算する。

この演算子を使用するDuration で有効な算術演算の型は以下のとおりである。 オーバーロードは

演算時間	*	長い	-->	期間
持続時間	/	長い	-->	期間

Parameters:

long value

Duration に乗じる値。

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

持続時間を整数値で乗算/除算する。 結果をこのDuration に代入する。

この演算子を使用したDuration の算術演算の型は以下の通りである。 オーバーロードは

演算時間	*	長い	-->	期間
持続時間	/	長い	-->	期間

Parameters:

long value

Duration を乗算/除算する値。

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

2つの持続時間を分割する。

この演算子を使用したDuration の算術演算は以下の通りである。

持続時間

/

期間

-->

長い

Parameters:

Duration rhs

このDuration を除算する期間。

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

積分値とDuration を掛け合わせる。

この演算子を使用するDuration で有効な算術演算の型は以下のとおりである。 オーバーロードは

長さ

*

期間

-->

期間

Parameters:

long value

このDuration に掛ける単位数。

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

このDuration の否定を返す。

const nothrow @nogc TickDuration opCast(T)()
if (is(immutable(T) == immutable(TickDuration)));

TickDuration は非推奨

を返す。 TickDurationを返す。 Duration. Duration と TickDuration との変換には std.conv.toを使うことである: duration.to!TickDuration()

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

Durationをブール値として使用できるようにする。

Returns:

true このDurationが0でない場合。

template split(units...) if (allAreAcceptedUnits!("weeks", "days", "hours", "minutes", "seconds", "msecs", "usecs", "hnsecs", "nsecs")([units]) && unitsAreInDescendingOrder([units]))

Durationを指定された単位に分割する。

splitは分割する時間単位のリストをテンプレート引数として受け取る。 時間単位の文字列は降順で与えなければならない。どのように返すかは これらの単位の値をどのように返すかは、使用するオーバーロードに依存する。

関数の引数を受け取るオーバーロードは、時間単位文字列が与えられた順に整数型を取る。 の整数を取る。 ref splitは、対応する各整数に単位の値を代入する。 に割り当てる。どのような整数型でも使用できるが、整数のオーバーフローを防ぐ試みは行われない。 整数のオーバーフローを防ごうとはしないので、単位を表す値が大きくない状況では小さな整数型は使わないこと。 小さな整数型は使用しないこと。 に収まらないような状況では、小さな整数型は使わないこと。

引数なしのオーバーロードは、指定された時間単位と同じ名前のメンバを持つ 文字列と同じ名前のメンバを持つ構造体中の単位の値を返す。 文字列である。メンバはすべてlongsである。 このオーバーロードは、時間文字列が与えられていない場合にも動作する。 weeksからhnsecsまでのすべての時間単位が提供される(ただし、nsecsは提供されない。 は常に0 )。

どちらのオーバーロードでも、Durationの値全体が各単位に分割される。 単位で分割される(すべての単位でDurationを分割し、要求された単位の値のみを提供するのではなく)。 の値のみを提供するのではなく)、Durationの値全体がユニット間で分割される。 が与えられた場合、結果は total.

"nsecs" はsplitで受け入れられるが、"years" と"months" は受け付けない。

負の持続時間の場合、スプリットの値はすべて負になる。

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)
if (units.length != 0 && (args.length == units.length) && allAreMutableIntegralTypes!Args);

const nothrow @nogc auto split();

同上

const nothrow @nogc @property long total(string units)()
if (units == "weeks" || units == "days" || units == "hours" || units == "minutes" || units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs");

const pure nothrow @safe string toString();

Duration に含まれるユニットの総数を返す。 そのため、split とは異なり、大きなユニットが取り除かれることはない。

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

Examples:

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)
if (is(immutable(D) == immutable(TickDuration)) && (units == "seconds" || units == "msecs" || units == "usecs" || units == "hnsecs" || units == "nsecs"));

TickDuration は DEPRECATED である。

TickDuration 、積分値または浮動小数点値として与えられた単位に変換する。 または浮動小数点値に変換する。

Parameters:

units	変換する単位。"seconds" およびそれ以下の単位に対応する。 のみ。
T	変換する型(積分型または浮動小数点型)。 浮動小数点型)。
D td	変換するTickDuration

Examples:

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)
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".

Parameters:

units	Duration の時間単位(例:"days" )。
long length	Duration のユニット数。

Examples:

// 一般的な
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);

// 非ジェネリック
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;

ClockType.normal でインスタンス化されたMonoTimeImpl のエイリアスである。これは でインスタンス化される。また、MonoTimeImpl のドキュメント(特に例)で使われているのもこれだ。 ドキュメント(特に例)でも使われている。 ほとんどのコードで使われるからだ。

struct MonoTimeImpl(ClockType clockType);

システムの単調時計のタイムスタンプを表す。

モノトニック・クロックとは、システムの時計とは異なり、常に前進し、決して後進しない時計のことである。 で表される)壁掛け時計の時間とは異なり、常に前進し、決して後退しない時計である。 std.datetime.SysTime).システムの壁掛け時計の時刻は、ユーザーによって、あるいはNTPなどのサービスを介してシステム自身によって調整することができる。 システムの壁掛け時計の時刻は、NTPのようなサービスを介して、ユーザーまたはシステム自身によって調整される。 そのため、壁掛け時計の時刻をタイミングに使用することは信頼できない。壁掛け時計の時刻を使用するタイマーは 壁掛け時計の時刻を使用するタイマーは、壁掛け時計の時刻を変更したり、壁掛け時計の時刻が変更されるのを待ったりすることで、簡単にオフにならない可能性がある。 壁掛け時計の時刻を使用するタイマーは、壁掛け時計の時刻を変更したり、プログラマーが指定した プログラマーが指定した時間とは異なる時間を待つことになる。しかし、モノトニック・クロックは は常に一定の速度で増加し、壁掛け時計の時刻の調整には影響されない。 しかし、モノトニック・クロックは常に一定の速度で増加し、壁掛け時計の時間の調整には影響されないため、タイマーや高精度のタイミングを必要とするものとの使用に理想的である。 高精度のタイミングを必要とするものとの使用に最適である。

そのため、MonoTimeはタイマーやタイミングに関わるものに使うべきである、 一方 std.datetime.SysTimeを使うべきである。 を使うべきである。

モノトニック・クロックは壁掛け時計の時間とは関係ない。むしろ 単調クロックは、壁掛け時計の時間とは関係なく、クロックの開始時(通常はシステムの起動時)から発生したクロックの目盛りの数として時間を保持する。 クロックがスタートしたとき(通常はシステムが起動したとき)から発生したクロックの刻みの数として時間を保持する。そのため つまり、2つの時点の間にどれだけの時間が経過したかを判断するには、一方の単調な時間を他方の単調な時間から引く。 を引いて、2つの時点の間に発生した刻みの数を決定する。 2つの時点の間に発生したティックの数を決定し、そのティックを1秒ごとに発生するティックの数で割る。 で除算される(MonoTime.ticksPerSecondで表される)。 で除算する。通常、MonoTimeはこれらの計算をプログラマーに代わって行う はプログラマーのためにこれらの計算を行うが、ticks とticksPerSecond プロパティが提供されている。 ticks。MonoTimeの通常の使用方法は以下の通りである。

    MonoTime before = MonoTime.currTime;
    // 何かをする...
    MonoTime after = MonoTime.currTime;
    Duration timeElapsed = after - before;

MonoTimeはMonoTimeImpl!(ClockType.normal) のエイリアスである。 のエイリアスであり、ほとんどのプログラムがモノトニック・クロックに使うべきものである。 MonoTimeImpl のほとんどのドキュメントで使われている。しかしMonoTimeImpl を必要とする稀なプログラムのために、他のクロック型をインスタンス化することができる。 他のクロック・タイプでインスタンス化することができる。

See Also:

ClockType

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

システムの単調時計の現在時刻。これは 壁掛け時計の時刻は(NTPなどで)調整できるからである。 NTPなどで)調整できるのに対し、モノトニッククロックは常に前進するからである。モノトニック・クロックの はシステム固有である。

Windowsでは、QueryPerformanceCounter 。Mac OS Xでは mach_absolute_time が使われ、他のPOSIXシステムでは clock_gettime が使われる。

警告警告: システムによっては、コンピュータがスリープまたは休止状態になると、 単調時計のカウントが停止することがある。 のカウントを停止することがある。そのため モノトニッククロックは実際の経過時間よりも短い時間を示すことがある。 を示すことがある。これはMac OS Xで起こることが知られている。 これはMac OS Xで起こることが知られている。 WindowsでもLinuxでも起こるかどうかはテストされていない。

MonoTimeImpl zero();

0 のMonoTime 。と矛盾しないように提供されている。 Duration.zero と矛盾しないように提供されており、MonoTime.init よりも明示的である。

MonoTimeImpl max();

可能な限り最大のMonoTime 。

MonoTimeImpl min();

MonoTime 可能な限り最大の負の値。

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

このMonoTimeと与えられたMonoTimeを比較する。

Returns:

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

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

2つのMonoTimesを引き算すると、次のようになる。 Durationとなる。 になる。

プログラムが時間を計る主な方法は、次のようなものだ。 である。

MonoTime before = MonoTime.currTime;
// 何かをする
MonoTime after = MonoTime.currTime;

// どれくらい時間がかかったか。
Duration timeElapsed = after - before;

を使うか、それを行うラッパー(ストップウォッチ型など)を使うことである。

警告 なぜなら Durationがhnsecsであるのに対し、MonoTimeはsystem であるのに対し、MonoTimeはhnsecであるため、通常はこのアサーションは失敗する。

auto before = MonoTime.currTime;
// 何かをする
auto after = MonoTime.currTime;
auto timeElapsed = after - before;
assert(before + timeElapsed == after);

これは一般的に問題ない。 システムの刻みから秒の型(hnsecs、nsecsなど)への変換は、その性質上、丸め誤差が発生する。 丸め誤差が発生する。 変換によって発生する小さな丸め誤差を避ける必要がある場合は ticks MonoTimeの"@property"プロパティを使用し、すべての計算を刻みで行う必要がある。 を使うのではなく Duration.

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

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

MonoTimeへの Durationを加算または減算すると その分だけ調整されたMonoTimeになる。

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

モノタイムの刻み数。

ほとんどのプログラムではこれを直接使うことはないはずだが、必要なプログラムのために公開されている。 必要なプログラムのために公開されている。

プログラムが目盛りを直接使う必要がある主な理由は、以下のような場合である。 システムクロックがhnsecsより高精度で、プログラムがそれを必要とする場合である。 または、hnsecsに変換することによって発生する丸め誤差を避ける必要がある場合である。 エラーを避ける必要がある場合である。

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

MonoTimeが1秒間に刻む刻み数、つまりシステムのモノクロックの分解能または周波数である。 すなわち、システムの単調クロックの分解能または周波数である。

例えば、システムクロックの分解能がマイクロ秒の場合、次のようになる。 ticksPerSecond は1_000_000 となる。

const pure nothrow string toString();

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

与えられた時間を、あるクロックの周波数/分解能から別のものに変換する。

See Also:

ticksToNSecs

Examples:

// 1ティックは1秒->1ティックはヘクトナノ秒
assert(convClockFreq(45, 1, 10_000_000) == 450_000_000);

// 1ティックは1マイクロ秒->1ティックは1ミリ秒
assert(convClockFreq(9029, 1_000_000, 1_000) == 9);

// 1ティックは1/3_515_654秒->1/1_001_010秒
assert(convClockFreq(912_319, 3_515_654, 1_001_010) == 259_764);

// 1目盛りは1/MonoTime.ticksPerSecond->1目盛りはナノ秒
// ticksToNSecsに等しい
auto nsecs = convClockFreq(1982, MonoTime.ticksPerSecond, 1_000_000_000);

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

の便利なラッパーである。 convClockFreqの便利なラッパーである。 MonoTime.ticksPerSecond をナノ秒に変換する。

これは主に、MonoTime.ticksPerSecond の分解能が ヘクト・ナノ秒の分解能より大きく、アプリケーションがヘクト・ナノ秒より高い精度を必要とする場合に使用される。 アプリケーションがヘクトナノ秒よりも高い精度を必要とする場合に使用される。

See Also:

convClockFreq

Examples:

auto before = MonoTime.currTime;
// 何かをする
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は非推奨。単調なタイムスタンプが必要な場合は MonoTime を使ってほしい。 を使うのではなく、Duration 。 を使うのではなく、TickDurationを使ってほしい。

システムクロックの目盛り単位で継続時間を表す。

システムクロックのティックは、システムが提供する最高精度でのシステムクロックのティックである。 システムクロックのティックである。

deprecated static immutable long ticksPerSec;

システムクロックが1秒間に何回刻むかを表す。

もしticksPerSec が0 ならば、TickDuration は現在のシステムで の値を取得できなかったことになる。 ticksPerSec の値を取得できなかったことになる。 TickDuration は動作しない。これは非常に異常なことだ。 しかし、それは非常に異常なことだ。

deprecated static immutable TickDuration appOrigin;

アプリケーションが起動したときのシステムクロック(TickDuration )。 アプリケーションが起動したときのシステムクロックの目盛り( )。

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

これはTickDuration(0) と同じだが、 プロパティを提供する と矛盾しないように提供されている。 zero プロパティを提供するDuration と矛盾しないように提供される。

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

TickDuration 可能な最大値。

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

TickDuration 可能な限り最大の負の値。

deprecated long length;

このTickDuration のシステムティック数。

このlength を秒数に変換するには、 で割る。 ticksPerSec で割ることで秒数に変換できる(または、適切なプロパティ関数を使用する)。 を使って)。

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

このTickDuration における総秒数を返す。

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

このTickDuration におけるミリ秒の総数を返す。

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

このTickDuration におけるマイクロ秒の総数を返す。

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

このTickDuration におけるヘクト・ナノ秒の総数を返す。

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

このTickDuration におけるナノ秒の総数を返す。

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

これにより、指定された長さの指定された時間単位からTickDuration を構築することができる。 を構築することができる。

Parameters:

units	TickDuration の時間単位(例:"msecs" )。
long length	TickDuration のユニット数。

const pure nothrow @nogc @safe Duration opCast(T)()
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)
if (op == "+" || op == "-");

つのTickDurationを加算または減算し、その結果をこの に代入する。 をこのTickDuration に代入する。

この演算子を使用したTickDuration の算術演算の型は以下の通りである。 である。

継続時間	+=	継続時間	-->	継続時間
継続時間	-=	継続時間	-->	継続時間

Parameters:

TickDuration rhs

TickDuration から加減する。 TickDuration.

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

2つのTickDurationを加算または減算する。

この演算子を使ったTickDuration の算術演算の型は以下の通りである。 である。

継続時間	+	継続時間	-->	チック・デュレーション
継続時間	-	継続時間	-->	継続時間

Parameters:

TickDuration rhs

TickDuration から加減する。 TickDuration.

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

このTickDuration の否定を返す。

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

演算子オーバーロード"<, >, <=, >="

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

この演算子を使ったTickDuration の算術の型は以下の通りである。 オーバーロードは

継続時間	*	である。	-->	継続時間
継続時間	*	浮動小数点	-->	継続時間

Parameters:

T value

この継続時間から除算する値。

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

この演算子を使用したTickDuration の算術演算の型は以下の通りである。 オーバーロードは

継続時間	/	長さ	-->	継続時間
継続時間	/	浮動小数点	-->	継続時間

Parameters:

T value

TickDuration から割り出す値。

Throws:

TimeException 0 で除算しようとした場合。

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

この演算子を使用したTickDuration の算術演算の有効な型は以下のとおりである。 オーバーロードは以下の通りである。

継続時間	*	である。	-->	継続時間
継続時間	*	浮動小数点	-->	継続時間

Parameters:

T value

このTickDuration から除算する値。

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

この演算子を使用したTickDuration の算術演算の合法的な型は以下のとおりである。 オーバーロードは

継続時間	/	長さ	-->	継続時間
継続時間	/	浮動小数点	-->	継続時間

Parameters:

T value

TickDuration から割り出す値。

Throws:

TimeException 0 で除算しようとした場合。

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

Parameters:

long ticks

TickDurationのティック数。

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

現在のシステムの目盛り。1秒あたりのティック数はシステムによって異なる。 currSystemTick 。単調クロックを使用しているため、相対的な時間値を比較することによる正確な計時を目的としていない。 相対的な時間値を比較することで正確なタイミングを計るためのものであり、現在のシステム時間を取得するためのものではない。 現在のシステム時刻を取得するためではない。

Windowsでは、QueryPerformanceCounter 。マック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で起こることが知られている。 これはMac OS Xで起こることが知られている。 WindowsでもLinuxでも起こるかどうかはテストされていない。

Throws:

TimeException 時刻の取得に失敗した場合。

pure nothrow @nogc @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"));

2つの時間単位を変換する一般的な方法。より小さい単位への変換は 単位への変換は、切り捨て除算を使用する。年と月は相互に変換できる。 小さな単位同士は変換できるが、年と月は変換できない。 年や月は(月や年の日数が異なるため)小さい単位に変換することも、小さい単位から変換することもできない。 月や年の日数が異なるため)。

Parameters:

from	変換元の時間の単位。
to	変換する時間の単位。
long value	変換する値。

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

class TimeException: object.Exception;

core.time.Exceptionで使用される例外型。

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

Parameters:

string msg	例外のメッセージ。
string file	例外が発生したファイル。
size_t line	例外が発生した行番号。
Throwable next	例外の連鎖の前の例外があれば、その例外。

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

Parameters:

string msg	例外のメッセージ。
Throwable next	例外の連鎖における前の例外。
string file	例外が発生したファイル。
size_t line	例外が発生した行番号。

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

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

継続時間の絶対値を返す。