このページの英語版を見る

std.datetime.interval


カテゴリー	関数
主な種類	Interval Direction
特殊インターバル	everyDayOfWeek everyMonth everyDuration
特殊区間	NegInfInterval PosInfInterval
下地範囲	IntervalRange NegInfIntervalRange PosInfIntervalRange
フラグ	PopFirst

License:

Boost License 1.0.

Authors:

Jonathan M Davis

ソース std/datetime/interval.d

enum Direction: int;

時間の方向を示す。その使用例のひとつは Interval's expand関数である。この関数は、区間を後方(過去)へ、前方(未来)へ、またはその両方へ拡張するかを指定するために使用する両方である。

bwd: 後方。
fwd: 前方。
both: 後方と前方の両方。

alias PopFirst = std.typecons.Flag!"popFirst".Flag;

範囲の作成時にpopFront をすぐに呼び出すかどうかを指定する。を直ちに呼び出すかどうかを示す。この考え方は、区間を生成するために使用されるいくつかの関数において、。ある区間に対して範囲を生成するために使用されるいくつかの関数において、front は必ずしも範囲によって生成される時点ではない、ということである。である必要はないということである。で、区間は月曜日から始まっている場合など)。に対処する方法が必要である。そのため、それに対処する方法が必要である。が関数が生成するものと一致するようにする。 PopFirst.yesを使ってが返される前に、popFront を呼び出す必要がある。が返される前に、front が関数が生成する時点であることを示す。である。最初の時点が生成関数にマッチしないようにする、 PopFront.no を使用する。

例えば、ある範囲の時点を生成するために使用した関数が、次のような場合である。を生成する関数が連続した復活祭を生成した場合(つまり、区間内のすべての復活祭を繰り返している)、最初の日付はおそらく復活祭ではない。を繰り返している)、最初の日付はおそらくイースターではない。使用方法 PopFirst.yesを使うと、範囲を返した関数にそれを伝えることになる。 popFront を返した関数に、その前がイースターになるように指示することになる。関数によって生成された次のイースター(順方向に反復する場合は、元のの次のイースターになる。イースターは、元のfront の次のイースターになる、後方へ反復する場合は、元のfront の前のイースターになる)。もし PopFirst.noを使用した場合、front は元の時点のままとなり、必ずしも元の時点とはならない。であるとは限らない。必ずしも範囲生成関数によって生成される時点ではない。によって生成される時点になるとは限らない。区間)。

もし PopFirst.noに設定されている場合、popFrontはを返す前に呼び出されない。

そうでない場合 PopFirst.yesに設定されていれば、範囲を返す前にpopFrontが呼ばれる。が呼び出される。

struct Interval(TP);

時間間隔を表す。

には始点と終点がある。 Intervalには始点と終点がある。時間の間隔は、始点から終点までの時間である。までの時間である。


[2010年1月5日～2010年3月10日)
[05:00:30 - 12:00:00)
[1982-01-04T08:59:00 - 2010-07-04T12:00:00)

範囲は Intervalから得ることができ反復される正確な時点は、範囲を生成する関数に依存する。その範囲を生成する関数に依存する。

pure this(U)(scope const TP begin, scope const U end) if (is(immutable(TP) == immutable(U)));

Parameters:

TP `begin`	区間を開始する時点。
U `end`	区間を終了する(区間には含まれない)時点。区間を終了する(区間には含まれない)時点。

Throws:

std.datetime.date.DateTimeExceptionもしendが beginより前であれば

例:

Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));

pure this(D)(scope const TP begin, scope const D duration) if (__traits(compiles, begin + duration));

Parameters:

TP `begin`	インターバルを開始する時点。
D `duration`	始点から終点までの期間。

Throws:

std.datetime.date.DateTimeExceptionその結果 end が begin.

例:」である。

assert(Interval!Date(Date(1996, 1, 2), dur!"days"(3)) ==
       Interval!Date(Date(1996, 1, 2), Date(1996, 1, 5)));

pure nothrow ref Interval opAssign(const ref Interval rhs);

Parameters:

Interval rhs この Intervalをこれに割り当てる。

pure nothrow ref Interval opAssign(Interval rhs);

Parameters:

Interval rhs この Intervalを割り当てる。

const pure nothrow @property TP begin();

区間の開始点。区間に含まれる。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).begin ==
       Date(1996, 1, 2));

pure @property void begin(TP timePoint);

区間の始点。区間に含まれる。

Parameters:

TP timePoint に設定する時点。 beginに設定する。

Throws:

std.datetime.date.DateTimeExceptionもしに設定する。

const pure nothrow @property TP end();

インターバルの終点。それは区間から除外される。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).end ==
       Date(2012, 3, 1));

pure @property void end(TP timePoint);

区間の終点。区間から除外される。

Parameters:

TP timePoint 終了を設定する時点。

Throws:

std.datetime.date.DateTimeExceptionもし間隔が無効である場合

const pure nothrow @property auto length();

begin からend までの期間を返す。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).length ==
       dur!"days"(5903));

const pure nothrow @property bool empty();

区間の長さが0かどうか、つまりbegin == end 。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(1996, 1, 2)).empty);
assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).empty);

const pure bool contains(scope const TP timePoint);

与えられた時点がこの区間内にあるかどうか。

Parameters:

TP timePoint この区間に含まれるかどうかをチェックする時点。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空である。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Date(1994, 12, 24)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Date(2000, 1, 5)));
assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Date(2012, 3, 1)));

const pure bool contains(scope const Interval interval);

与えられた区間が完全にこの区間内にあるかどうか。

Parameters:

Interval interval この区間に含まれるかどうかをチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionどちらかの区間がが空の場合。

例:」である。

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            Interval!Date(Date(1998, 2, 28), Date(2013, 5, 1))));

const pure bool contains(scope const PosInfInterval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

この区間が空でない限り)常に偽を返す。なぜなら、正の無限大に向かう区間は、決して有限のに含まれることはないからだ。

Parameters:

PosInfInterval!TP interval この区間に含まれるかどうかをチェックするための区間である。

Throws:

std.datetime.date.DateTimeExceptionもしこの区間がが空の場合。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            PosInfInterval!Date(Date(1999, 5, 4))));

const pure bool contains(scope const NegInfInterval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

この区間が空でない限り)常に偽を返す。なぜなら、負の無限大から始まる区間は決してを返す。

Parameters:

NegInfInterval!TP interval この区間に含まれるかどうかをチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionもしこの区間がが空の場合。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).contains(
            NegInfInterval!Date(Date(1996, 5, 4))));

const pure bool isBefore(scope const TP timePoint);

このインターバルが与えられた時点より前にあるかどうか。

Parameters:

TP timePoint このインターバルが指定された時点より前かどうかをチェックする時点。である。

Throws:

std.datetime.date.DateTimeExceptionこのインターバルが空である。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Date(1994, 12, 24)));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Date(2000, 1, 5)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Date(2012, 3, 1)));

const pure bool isBefore(scope const Interval interval);

この区間が与えられた区間より前にあり、その区間と交差しないかどうか。であるかどうか。

Parameters:

Interval interval この区間に対してチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionどちらかの区間がが空の場合。

例:」である。

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(2012, 3, 1), Date(2013, 5, 1))));

const pure bool isBefore(scope const PosInfInterval!TP interval);

この区間が与えられた区間より前にあり、その区間と交差しないかどうか。であるかどうか。

Parameters:

PosInfInterval!TP interval この区間に対してチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionもしこの区間がが空の場合。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            PosInfInterval!Date(Date(2013, 3, 7))));

const pure bool isBefore(scope const NegInfInterval!TP interval);

この区間が与えられた区間より前にあり、その区間と交差しないかどうか。であるかどうか。

有限区間は負の無限大から始まる区間より前にあることはないため、(この区間が空でない限り)常に偽を返す。なぜなら、有限の区間が負の無限大から始まる区間の前にあることはあり得ないからである。

Parameters:

NegInfInterval!TP interval この区間に対してチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionこのインターバルがが空の場合。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isBefore(
            NegInfInterval!Date(Date(1996, 5, 4))));

const pure bool isAfter(scope const TP timePoint);

このインターバルが与えられた時点より後にあるかどうか。

Parameters:

TP timePoint この区間が指定された時点より後にあるかどうかをチェックする。である。

Throws:

std.datetime.date.DateTimeExceptionこの間隔が空である。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Date(1994, 12, 24)));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Date(2000, 1, 5)));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Date(2012, 3, 1)));

const pure bool isAfter(scope const Interval interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

Parameters:

Interval interval この区間とチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionどちらかのインターバルがが空の場合。

例:」である。

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(1989, 3, 1), Date(1996, 1, 2))));

const pure bool isAfter(scope const PosInfInterval!TP interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

有限の区間は正の無限大に向かう区間の後にはあり得ないので、(この区間が空でない限り)常に偽を返す。なぜなら、有限の区間が正の無限大に向かう区間の後にあることはあり得ないからである。

Parameters:

PosInfInterval!TP interval この区間と照合する区間。

Throws:

std.datetime.date.DateTimeExceptionこのインターバルがが空の場合。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            PosInfInterval!Date(Date(1999, 5, 4))));

const pure bool isAfter(scope const NegInfInterval!TP interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

Parameters:

NegInfInterval!TP interval この区間とチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionもしこのインターバルがが空の場合。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAfter(
            NegInfInterval!Date(Date(1996, 1, 2))));

const pure bool intersects(scope const Interval interval);

与えられた区間がこの区間と重なっているかどうか。

Parameters:

Interval interval この区間との交差をチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionどちらかの区間がが空の場合。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            Interval!Date(Date(1989, 3, 1), Date(1996, 1, 2))));

const pure bool intersects(scope const PosInfInterval!TP interval);

与えられた区間がこの区間と重なっているかどうか。

Parameters:

PosInfInterval!TP interval この区間との交差をチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空である。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure bool intersects(scope const NegInfInterval!TP interval);

与えられた区間がこの区間と重なっているかどうか。

Parameters:

NegInfInterval!TP interval この区間との交差をチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空である。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            NegInfInterval!Date(Date(1996, 1, 2))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersects(
            NegInfInterval!Date(Date(2000, 1, 2))));

const Interval intersection(scope const Interval interval);

2つの区間の交点を返す

Parameters:

Interval interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しないか、どちらかの区間が空である。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2000, 8, 2)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))) ==
       Interval!Date(Date(1999, 1 , 12), Date(2011, 9, 17)));

const Interval intersection(scope const PosInfInterval!TP interval);

2つの区間の交点を返す

Parameters:

PosInfInterval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合、またはこの区間が空の場合。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2012, 3, 1)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            PosInfInterval!Date(Date(1999, 1, 12))) ==
       Interval!Date(Date(1999, 1 , 12), Date(2012, 3, 1)));

const Interval intersection(scope const NegInfInterval!TP interval);

2つの区間の交点を返す

Parameters:

NegInfInterval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合、またはこの区間が空の場合。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            NegInfInterval!Date(Date(1999, 7, 6))) ==
       Interval!Date(Date(1996, 1 , 2), Date(1999, 7, 6)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).intersection(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2012, 3, 1)));

const pure bool isAdjacent(scope const Interval interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

Interval interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

Throws:

std.datetime.date.DateTimeExceptionどちらかの区間がが空の場合

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(1990, 7, 6), Date(1996, 1, 2))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(2012, 3, 1), Date(2013, 9, 17))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(1989, 3, 1), Date(2012, 3, 1))));

const pure bool isAdjacent(scope const PosInfInterval!TP interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

PosInfInterval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

Throws:

std.datetime.date.DateTimeExceptionもしこの区間が空である。

例:

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure bool isAdjacent(scope const NegInfInterval!TP interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

NegInfInterval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

Throws:

std.datetime.date.DateTimeExceptionもしこの区間が空である。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            NegInfInterval!Date(Date(1996, 1, 2))));

assert(!Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).isAdjacent(
            NegInfInterval!Date(Date(2000, 1, 2))));

const Interval merge(scope const Interval interval);

2つの区間の"共用体"を返す。

Parameters:

Interval interval この区間とマージする区間。

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差せず隣接していない場合、またはどちらかの区間が空の場合。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       Interval!Date(Date(1990, 7 , 6), Date(2012, 3, 1)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            Interval!Date(Date(2012, 3, 1), Date(2013, 5, 7))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2013, 5, 7)));

const PosInfInterval!TP merge(scope const PosInfInterval!TP interval);

2つの区間の"共用体"を返す。

Parameters:

PosInfInterval!TP interval この区間とマージする区間。

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差せず隣接していない場合、またはこの区間が空の場合。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            PosInfInterval!Date(Date(2012, 3, 1))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

const NegInfInterval!TP merge(scope const NegInfInterval!TP interval);

2つの区間の"共用体"を返す。

Parameters:

NegInfInterval!TP interval この区間とマージする区間。

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差せず隣接していない場合、またはこの区間が空の場合。

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            NegInfInterval!Date(Date(1996, 1, 2))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).merge(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       NegInfInterval!Date(Date(2013, 1 , 12)));

const pure Interval span(scope const Interval interval);

つの区間のうち最も古い時点から、2つの区間のうち最も遅い時点まで(ただし、2つの区間のうち最も古い時点は含まない)をカバーする区間を返す。の最も古い時点から、2つの区間区間を返す。

Parameters:

Interval interval この区間とともにスパンを作成する区間。

Throws:

std.datetime.date.DateTimeExceptionどちらかの区間がが空の場合。

例:」である。

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            Interval!Date(Date(1990, 7, 6), Date(1991, 1, 8))) ==
       Interval!Date(Date(1990, 7 , 6), Date(2012, 3, 1)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            Interval!Date(Date(2012, 3, 1), Date(2013, 5, 7))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2013, 5, 7)));

const pure PosInfInterval!TP span(scope const PosInfInterval!TP interval);

つの区間のうち最も古い時点から、2つの区間のうち最も遅い時点まで(を含まない)の区間を返す。の最も古い時点から、2つの区間区間を返す。

Parameters:

PosInfInterval!TP interval この区間とともにスパンを作成する区間。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空の場合

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            PosInfInterval!Date(Date(2050, 1, 1))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

const pure NegInfInterval!TP span(scope const NegInfInterval!TP interval);

つの区間のうち最も古い時点から、2つの区間のうち最も遅い時点まで(を含まない)の区間を返す。の最も古い時点から、2つの区間区間を返す。

Parameters:

NegInfInterval!TP interval この区間とともにスパンを作成する区間。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空の場合

例:

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            NegInfInterval!Date(Date(1602, 5, 21))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1)).span(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       NegInfInterval!Date(Date(2013, 1 , 12)));

pure void shift(D)(D duration) if (__traits(compiles, begin + duration));

指定された継続時間だけ、区間を時間的に前方または後方にシフトする。 (正の継続時間は間隔を前方にシフトし、負の継続時間は逆方向にシフトする)。事実上、begin += duration end += duration.

Parameters:

D duration 間隔をずらす期間。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空であるまたは結果の間隔が無効な場合。

例:」である。

auto interval1 = Interval!Date(Date(1996, 1, 2), Date(2012, 4, 5));
auto interval2 = Interval!Date(Date(1996, 1, 2), Date(2012, 4, 5));

interval1.shift(dur!"days"(50));
assert(interval1 == Interval!Date(Date(1996, 2, 21), Date(2012, 5, 25)));

interval2.shift(dur!"days"(-50));
assert(interval2 == Interval!Date(Date(1995, 11, 13), Date(2012, 2, 15)));

void shift(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

区間を指定された年数または月数だけ時間的に前方または後方にシフトする。 (正の年数および月数を指定すると，時間間隔は前方にシフトしを前方にシフトし、負の数を後方にシフトする)。指定された年数と月数を、開始と終了の両方に加算する。これは効果的に add!"years"()そして add!"months"() を呼び出す。

Parameters:

T `years`	間隔をずらす年数。
T `months`	間隔をずらす月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 begin end をオーバーフローさせるかどうか。をインクリメントする。

Throws:

std.datetime.date.DateTimeExceptionこの間隔がが空の場合、または結果の間隔が無効な場合。

例:」である。

auto interval1 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));
auto interval2 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));

interval1.shift(2);
assert(interval1 == Interval!Date(Date(1998, 1, 2), Date(2014, 3, 1)));

interval2.shift(-2);
assert(interval2 == Interval!Date(Date(1994, 1, 2), Date(2010, 3, 1)));

pure void expand(D)(D duration, Direction dir = Direction.both) if (__traits(compiles, begin + duration));

区間を時間的に前方または後方に拡大する。効果的である、 begin -= duration および/またはend += duration を行う。を行う。によって決定される。によって決定される。

Parameters:

D `duration`	区間を拡大する期間。
Direction `dir`	区間を拡大する時間の方向。

Throws:

std.datetime.date.DateTimeExceptionこの区間が空であるまたは結果の区間が無効な場合。

例:」である。

auto interval1 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));
auto interval2 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));

interval1.expand(2);
assert(interval1 == Interval!Date(Date(1994, 1, 2), Date(2014, 3, 1)));

interval2.expand(-2);
assert(interval2 == Interval!Date(Date(1998, 1, 2), Date(2010, 3, 1)));

void expand(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes, Direction dir = Direction.both) if (isIntegral!T);

区間を時間的に前方または後方に拡大する。効果的には事実上、begin から指定された月/年数を引き、に追加する。 end に追加する。によって決定される。

Parameters:

T `years`	区間を何年分拡大するか。
T `months`	間隔を拡大する月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 begin end をオーバーフローさせるかどうか。をインクリメントする。
Direction `dir`	区間を拡大する時間方向。

Throws:

std.datetime.date.DateTimeExceptionこの間隔が空であるかこの区間が空である場合、または結果の区間が無効である場合。

例:」である。

auto interval1 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));
auto interval2 = Interval!Date(Date(1996, 1, 2), Date(2012, 3, 1));

interval1.expand(2);
assert(interval1 == Interval!Date(Date(1994, 1, 2), Date(2014, 3, 1)));

interval2.expand(-2);
assert(interval2 == Interval!Date(Date(1998, 1, 2), Date(2010, 3, 1)));

const IntervalRange!(TP, Direction.fwd) fwdRange(TP delegate(scope const TP) func, PopFirst popFirst = PopFirst.no);

区間を反復して進む範囲を返す。 beginを返す。点を生成する。

範囲のfront は、区間のbegin である。は、popFront が呼び出されたときに、次のfront を生成するために使用される。もし popFirstがPopFirst.yes の場合、popFront が呼び出される。が返される前に呼び出される(したがって、front は funcが生成することになる)。

もしfuncが範囲の現在の以下の時点を生成することがあれば、が呼び出される。現在のfront 。 std.datetime.date.DateTimeExceptionがスローされる。範囲は空になり、funcが間隔の以上の時点を生成したときに反復が完了する。がインターバルのend と等しいか、それを超える時点を生成するときに、範囲は空になり、反復は完了する。

このモジュールには、一般的なデリゲートを生成するヘルパー関数がある。に渡す一般的なデリゲートを生成するヘルパー関数がある。 fwdRange.これらのドキュメントは "範囲生成関数"で始まるので、簡単に検索できる。

Parameters:

TP delegate(scope const TP) `func`	区間の時点を生成するために使われる関数である。を生成するために使用される関数。
PopFirst `popFirst`	popFront を返す前にを呼び出すかどうか。

Throws:

std.datetime.date.DateTimeExceptionこの区間がが空の場合。

警告 funcは論理的に純粋でなければならない。理想的には、func は純粋関数への関数ポインタであることが理想的である。を純粋な関数への関数ポインタとするのが理想的だが、funcを純粋であることを強制するのは、有用であるにはあまりにも制限が多すぎる。を生成する関数を持つという使い勝手を得るためには、funcは純粋な関数への関数ポインタでなければならない。に渡す関数を生成する関数を持つという使いやすさを実現するためには、funcは純粋関数への関数ポインタでなければならない。 fwdRangeに渡す関数を生成する関数を持つという使い勝手を得るためには、funcはデリゲートでなければならない。

funcが呼び出されるたびに変化する状態を保持する場合、いくつかのアルゴリズムは正しく動作しない。いくつかのアルゴリズムは正しく動作しない。 save が範囲の状態を本当に保存していなかったことになる。このようなバグを避けるには、論理的に純粋でないデリゲートをに論理的に純粋でないデリゲートを渡さないことだ。 fwdRange.に論理的に純粋でないデリゲートを渡してはならない。に論理的に純粋でないデリゲートを渡してはならない。を返さなければならない。

もちろん、このモジュールのどの関数にもこの問題はない、カスタム・デリゲートを作成する場合にのみ関係する。

例:

auto interval = Interval!Date(Date(2010, 9, 1), Date(2010, 9, 9));
auto func = delegate (scope const Date date) // 偶数日を繰り返す。
            {
                if ((date.day & 1) == 0)
                    return date + dur!"days"(2);

                return date + dur!"days"(1);
            };
auto range = interval.fwdRange(func);

// 奇数日。PopFirst.yesを使えば、Date(2010, 9, 2)となる。
assert(range.front == Date(2010, 9, 1));

range.popFront();
assert(range.front == Date(2010, 9, 2));

range.popFront();
assert(range.front == Date(2010, 9, 4));

range.popFront();
assert(range.front == Date(2010, 9, 6));

range.popFront();
assert(range.front == Date(2010, 9, 8));

range.popFront();
assert(range.empty);

const IntervalRange!(TP, Direction.bwd) bwdRange(TP delegate(scope const TP) func, PopFirst popFirst = PopFirst.no);

区間を逆方向に反復する範囲を返す。 endを逆行する範囲を返す。を使用する。

範囲のfront は、区間のend である。は、popFront が呼び出されたときに、次のfront を生成するために使用される。もし popFirstがPopFirst.yes の場合、popFront が呼び出される。が返される前に呼び出される(したがって、front は funcが生成することになる)。

もしfuncが範囲内の現在の。 front 以上の時点を生成することがあれば std.datetime.date.DateTimeExceptionがスローされる。範囲は空になり、funcが間隔の以下の時点を生成したときに反復が完了する。がインターバルのbegin 以下の時点を生成するとき、範囲は空になり、反復は完了する。

このモジュールには、一般的なデリゲートを生成するヘルパー関数がある。に渡す一般的なデリゲートを生成するヘルパー関数がある。 bwdRange.これらのドキュメントは "範囲生成関数"で始まるので、簡単に検索できる。

Parameters:

TP delegate(scope const TP) `func`	区間の時点を生成するために使われる関数である。を生成するために使用される関数。
PopFirst `popFirst`	popFront を返す前にを呼び出すかどうか。

Throws:

std.datetime.date.DateTimeExceptionこの区間がが空の場合。

警告 funcは論理的に純粋でなければならない。理想的には、func は純粋関数への関数ポインタであることが理想的である。を純粋な関数への関数ポインタとするのが理想的だが、funcを純粋であることを強制するのは、有用であるにはあまりにも制限が多すぎる。を生成する関数を持つという使いやすさを得るためには、funcは論理的に純粋でなければならない。関数を生成し、fwdRange に渡すという使いやすさを実現するためには、funcはデリゲートでなければならない。デリゲートでなければならない。

funcが呼び出されるたびに変化する状態を保持する場合、いくつかのアルゴリズムは正しく動作しない。いくつかのアルゴリズムは正しく動作しない。 save が範囲の状態を本当に保存していなかったことになる。このようなバグを避けるためには、論理的に純粋でないデリゲートをに渡してはならない。論理的に純粋でないデリゲートをfwdRange に渡してはならない。に同じ時点を与えた場合、2回とも同じ結果を返さなければならない。を返さなければならない。

もちろん、このモジュールのどの関数にもこの問題はない、カスタムデリゲートにのみ関係する。

例:

auto interval = Interval!Date(Date(2010, 9, 1), Date(2010, 9, 9));
auto func = delegate (scope const Date date) // 偶数日を反復処理する。
            {
                if ((date.day & 1) == 0)
                    return date - dur!"days"(2);

                return date - dur!"days"(1);
            };
auto range = interval.bwdRange(func);

// 奇数日。PopFirst.yesを使えば、Date(2010, 9, 8)となる。
assert(range.front == Date(2010, 9, 9));

range.popFront();
assert(range.front == Date(2010, 9, 8));

range.popFront();
assert(range.front == Date(2010, 9, 6));

range.popFront();
assert(range.front == Date(2010, 9, 4));

range.popFront();
assert(range.front == Date(2010, 9, 2));

range.popFront();
assert(range.empty);

const nothrow @safe string toString(); const void toString(Writer)(ref Writer w) if (isOutputRange!(Writer, char));

この区間を文字列に変換する。

Parameters:

Writer w char 。出力範囲

Returns:

出力範囲を使用しない場合はstring 、それ以外はvoid 。

struct PosInfInterval(TP);

正の無限大を終点とする時間間隔を表す。

を反復する範囲はすべて無限大である。 PosInfIntervalを反復する範囲はすべて無限大である。したがってを反復する範囲はすべて無限である。 PosInfIntervalを使う主な目的はを作ることである。

pure nothrow this(scope const TP begin);

Parameters:

TP begin 区間を開始する時点。

例:

auto interval = PosInfInterval!Date(Date(1996, 1, 2));

pure nothrow ref PosInfInterval opAssign(const ref PosInfInterval rhs);

Parameters:

PosInfInterval rhs これに割り当てるPosInfInterval 。

pure nothrow ref PosInfInterval opAssign(PosInfInterval rhs);

Parameters:

PosInfInterval rhs これに割り当てるPosInfInterval 。

const pure nothrow @property TP begin();

区間の始点。区間に含まれる。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).begin == Date(1996, 1, 2));

pure nothrow @property void begin(TP timePoint);

区間の始点。区間に含まれる。

Parameters:

TP timePoint に設定する時点。 beginに設定する。

enum bool empty;

インターバルの長さが0かどうか。常にfalseを返す。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).empty);

const pure nothrow bool contains(TP timePoint);

与えられた時点がこの区間内にあるかどうか。

Parameters:

TP timePoint この区間に含まれるかどうかをチェックする時点。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).contains(Date(1994, 12, 24)));
assert(PosInfInterval!Date(Date(1996, 1, 2)).contains(Date(2000, 1, 5)));

const pure bool contains(scope const Interval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

Parameters:

Interval!TP interval この区間に含まれるかどうかをチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).contains(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).contains(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).contains(
            Interval!Date(Date(1998, 2, 28), Date(2013, 5, 1))));

const pure nothrow bool contains(scope const PosInfInterval interval);

与えられた区間が完全にこの区間内にあるかどうか。

Parameters:

PosInfInterval interval この区間に含まれるかどうかをチェックする区間。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).contains(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).contains(
            PosInfInterval!Date(Date(1995, 7, 2))));

const pure nothrow bool contains(scope const NegInfInterval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

正の無限大に向かう区間は負の無限大から始まる区間を含むことができないので、常に偽を返す。まで続く区間が負の無限大から始まる区間を含むことはあり得ないからである。

Parameters:

NegInfInterval!TP interval この区間に含まれるかどうかをチェックする区間。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).contains(
            NegInfInterval!Date(Date(1996, 5, 4))));

const pure nothrow bool isBefore(scope const TP timePoint);

この区間が与えられた時点より前にあるかどうか。

正の無限大に向かう区間は、どの時点よりも前になることはない。に向かう区間はどの時点よりも前になることはないからである。

Parameters:

TP timePoint この区間がその時点より前にあるかどうかをチェックするための時点は以下の通りである。である。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(Date(1994, 12, 24)));
assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(Date(2000, 1, 5)));

const pure bool isBefore(scope const Interval!TP interval);

この区間が与えられた区間より前にあり、区間と交差していないかどうか。であるかどうか。

与えられた区間が空でない限り)常に偽を返す。というのも、正の無限大に向かう区間は、他のどの区間よりも前にあることはないからである。を返す。

Parameters:

Interval!TP interval この区間に対してチェックする区間。

Throws:

std.datetime.date.DateTimeExceptionもし与えられた区間が空の場合

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

const pure nothrow bool isBefore(scope const PosInfInterval interval);

この区間が与えられた区間より前にあり、かつ与えられた区間と交差していないかどうか。であるかどうか。

正の無限大に向かう区間は他の区間より前になることはないため、常に偽を返す。なぜなら、正の無限大に向かう区間は、他のどの区間よりも前になることはないからである。

Parameters:

PosInfInterval interval この区間に対してチェックする区間。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(
            PosInfInterval!Date(Date(1992, 5, 4))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(
            PosInfInterval!Date(Date(2013, 3, 7))));

const pure nothrow bool isBefore(scope const NegInfInterval!TP interval);

この区間が与えられた区間より前にありであるかどうか。

Parameters:

NegInfInterval!TP interval この区間に対してチェックする区間。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isBefore(
            NegInfInterval!Date(Date(1996, 5, 4))));

const pure nothrow bool isAfter(scope const TP timePoint);

この間隔が指定された時点の後かどうか。

Parameters:

TP timePoint この区間が指定された時点より後にあるかどうかをチェックする。である。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).isAfter(Date(1994, 12, 24)));
assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(Date(2000, 1, 5)));

const pure bool isAfter(scope const Interval!TP interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

Parameters:

Interval!TP interval この区間とチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられたインターバルが空の場合

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            Interval!Date(Date(1989, 3, 1), Date(1996, 1, 2))));

const pure nothrow bool isAfter(scope const PosInfInterval interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

正の無限大に向かう区間は、他の正の無限大に向かう区間の後にはあり得ないので、常に偽を返す。なぜなら、正の無限大に向かう区間は、正の無限大に向かう別の区間の後には決して存在し得ないからである。

Parameters:

PosInfInterval interval この区間に対してチェックする区間。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            PosInfInterval!Date(Date(1990, 1, 7))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            PosInfInterval!Date(Date(1999, 5, 4))));

const pure nothrow bool isAfter(scope const NegInfInterval!TP interval);

この区間が指定された区間より後にあり、交差していないかどうか。どうか。

Parameters:

NegInfInterval!TP interval この区間とチェックする区間。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            NegInfInterval!Date(Date(1996, 1, 2))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAfter(
            NegInfInterval!Date(Date(2000, 7, 1))));

const pure bool intersects(scope const Interval!TP interval);

与えられたインターバルがこのインターバルに重なるかどうか。

Parameters:

Interval!TP interval この区間との交差をチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            Interval!Date(Date(1989, 3, 1), Date(1996, 1, 2))));

const pure nothrow bool intersects(scope const PosInfInterval interval);

与えられた区間がこの区間と重なっているかどうか。

正の無限大に向かう2つの区間は常に重なるので、常に真を返す。は常に重なるからである。

Parameters:

PosInfInterval interval このである。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            PosInfInterval!Date(Date(1990, 1, 7))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            PosInfInterval!Date(Date(1999, 5, 4))));

const pure nothrow bool intersects(scope const NegInfInterval!TP interval);

与えられたインターバルがこのインターバルに重なるかどうか。

Parameters:

NegInfInterval!TP interval この区間との交差をチェックするとの交差をチェックする区間。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            NegInfInterval!Date(Date(1996, 1, 2))));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersects(
            NegInfInterval!Date(Date(2000, 7, 1))));

const Interval!TP intersection(scope const Interval!TP interval);

つの区間の交点を返す

Parameters:

Interval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合、または与えられた区間が空の場合。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2000, 8, 2)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))) ==
       Interval!Date(Date(1999, 1 , 12), Date(2011, 9, 17)));

const pure nothrow PosInfInterval intersection(scope const PosInfInterval interval);

2つの区間の交点を返す

Parameters:

PosInfInterval interval この区間と交差する区間

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            PosInfInterval!Date(Date(1999, 1, 12))) ==
       PosInfInterval!Date(Date(1999, 1 , 12)));

const Interval!TP intersection(scope const NegInfInterval!TP interval);

つの区間の交点を返す

Parameters:

NegInfInterval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            NegInfInterval!Date(Date(1999, 7, 6))) ==
       Interval!Date(Date(1996, 1 , 2), Date(1999, 7, 6)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).intersection(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       Interval!Date(Date(1996, 1 , 2), Date(2013, 1, 12)));

const pure bool isAdjacent(scope const Interval!TP interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

Interval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).isAdjacent(
            Interval!Date(Date(1989, 3, 1), Date(1996, 1, 2))));

assert(!PosInfInterval!Date(Date(1999, 1, 12)).isAdjacent(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

const pure nothrow bool isAdjacent(scope const PosInfInterval interval);

与えられた区間がこの区間に隣接しているかどうか。

正の無限大に向かう2つの区間は決して隣接できないので、常に偽を返すに向かう2つの区間が隣接することはあり得ないからである。

Parameters:

PosInfInterval interval この区間に隣接するかどうかをチェックする区間に隣接しているかどうかをチェックする。

例:

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAdjacent(
            PosInfInterval!Date(Date(1990, 1, 7))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAdjacent(
            PosInfInterval!Date(Date(1996, 1, 2))));

const pure nothrow bool isAdjacent(scope const NegInfInterval!TP interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

NegInfInterval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

例:

assert(PosInfInterval!Date(Date(1996, 1, 2)).isAdjacent(
            NegInfInterval!Date(Date(1996, 1, 2))));

assert(!PosInfInterval!Date(Date(1996, 1, 2)).isAdjacent(
            NegInfInterval!Date(Date(2000, 7, 1))));

const PosInfInterval merge(scope const Interval!TP interval);

つの区間の共用体を返す。

Parameters:

Interval!TP interval この区間とマージする区間。

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差せず隣接していない場合、または与えられた区間がが空の場合。

注釈:」である。のオーバーロードはない。 mergeのオーバーロードはない。 NegInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(PosInfInterval!Date(Date(1996, 1, 2)).merge(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).merge(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

const pure nothrow PosInfInterval merge(scope const PosInfInterval interval);

2つの区間の"共用体"を返す。

Parameters:

PosInfInterval interval この区間とマージする区間。

注釈: 2つの区間をマージする。のオーバーロードはない。 mergeを取る NegInfInterval のオーバーロードはない。を取るオーバーロードは存在しない。はありえないからである。

例:」である。

assert(PosInfInterval!Date(Date(1996, 1, 2)).merge(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).merge(
            PosInfInterval!Date(Date(1999, 1, 12))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

const pure PosInfInterval span(scope const Interval!TP interval);

2つの区間のうち、最も古い時点から、最も古い時点までの区間を返す。 2つの区間の最も古い時点から、2つの区間の最も遅い時点までをカバーする区間を返す。区間を返す。

Parameters:

Interval!TP interval この区間である。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

注釈: のオーバーロードはない。 spanのオーバーロードはない。 NegInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(PosInfInterval!Date(Date(1996, 1, 2)).span(
            Interval!Date(Date(500, 8, 9), Date(1602, 1, 31))) ==
       PosInfInterval!Date(Date(500, 8, 9)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).span(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).span(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

const pure nothrow PosInfInterval span(scope const PosInfInterval interval);

Parameters:

PosInfInterval interval この区間である。

注釈のオーバーロードはない。 spanを取る NegInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(PosInfInterval!Date(Date(1996, 1, 2)).span(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       PosInfInterval!Date(Date(1990, 7 , 6)));

assert(PosInfInterval!Date(Date(1996, 1, 2)).span(
            PosInfInterval!Date(Date(1999, 1, 12))) ==
       PosInfInterval!Date(Date(1996, 1 , 2)));

pure nothrow void shift(D)(D duration) if (__traits(compiles, begin + duration));

このインターバルのbegin を、指定された継続時間だけ時間的に前方または後方にシフトする。を前方または後方にシフトする(正の持続時間を指定すると区間が前方にシフトし、負の持続時間を指定すると後方にシフトする)。負の場合は後ろにシフトする)。実質的には begin += duration.

Parameters:

D duration で区間をシフトする。

例:

auto interval1 = PosInfInterval!Date(Date(1996, 1, 2));
auto interval2 = PosInfInterval!Date(Date(1996, 1, 2));

interval1.shift(dur!"days"(50));
assert(interval1 == PosInfInterval!Date(Date(1996, 2, 21)));

interval2.shift(dur!"days"(-50));
assert(interval2 == PosInfInterval!Date(Date(1995, 11, 13)));

void shift(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

この間隔のbegin を時間的に前方または後方にシフトする。を、指定された年数または月数だけ前方または後方にシフトする(正の年数と月数を指定するとを指定すると、区間は前方にシフトする。は後ろにシフトする)。これは、指定された年数と月数を begin.を効果的に呼び出す。 add!"years"()を呼び出す。 add!"months"()begin を呼び出す。を呼び出す。

Parameters:

T `years`	間隔をずらす年数。
T `months`	間隔をずらす月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 begin で、その月をインクリメントする。

Throws:

std.datetime.date.DateTimeExceptionこの間隔がが空の場合、または結果の間隔が無効な場合。

例:」である。

auto interval1 = PosInfInterval!Date(Date(1996, 1, 2));
auto interval2 = PosInfInterval!Date(Date(1996, 1, 2));

interval1.shift(dur!"days"(50));
assert(interval1 == PosInfInterval!Date(Date(1996, 2, 21)));

interval2.shift(dur!"days"(-50));
assert(interval2 == PosInfInterval!Date(Date(1995, 11, 13)));

pure nothrow void expand(D)(D duration) if (__traits(compiles, begin + duration));

区間を時間的に逆方向へ拡大する。実質的には begin -= duration.

Parameters:

D duration で区間を拡大する。

例:

auto interval1 = PosInfInterval!Date(Date(1996, 1, 2));
auto interval2 = PosInfInterval!Date(Date(1996, 1, 2));

interval1.expand(dur!"days"(2));
assert(interval1 == PosInfInterval!Date(Date(1995, 12, 31)));

interval2.expand(dur!"days"(-2));
assert(interval2 == PosInfInterval!Date(Date(1996, 1, 4)));

void expand(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

区間を時間的に前方または後方に拡大する。効果的には begin から指定された月/年数を引く。

Parameters:

T `years`	区間を拡張する年数。
T `months`	間隔を拡張する月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 begin で、その月をインクリメントする。

Throws:

std.datetime.date.DateTimeExceptionこの間隔がが空の場合、または結果の間隔が無効な場合。

例:」である。

auto interval1 = PosInfInterval!Date(Date(1996, 1, 2));
auto interval2 = PosInfInterval!Date(Date(1996, 1, 2));

interval1.expand(2);
assert(interval1 == PosInfInterval!Date(Date(1994, 1, 2)));

interval2.expand(-2);
assert(interval2 == PosInfInterval!Date(Date(1998, 1, 2)));

const PosInfIntervalRange!TP fwdRange(TP delegate(scope const TP) func, PopFirst popFirst = PopFirst.no);

区間を反復して進む範囲を返す。 beginを返す。点を生成する。

もしfuncが範囲の現在の以下の時点を生成することがあれば、が呼び出される。現在のfront 。 std.datetime.date.DateTimeExceptionがスローされる。

このモジュールには、一般的なデリゲートを生成するヘルパー関数がある。に渡す一般的なデリゲートを生成するヘルパー関数がある。 fwdRange.それらのドキュメントは "範囲生成関数"で始まる。

Parameters:

TP delegate(scope const TP) `func`	区間の時点を生成するために使われる関数である。を生成するために使用される関数。
PopFirst `popFirst`	popFront を返す前にを呼び出すかどうか。

Throws:

std.datetime.date.DateTimeExceptionこの区間がが空の場合。

もちろん、このモジュールのどの関数にもこの問題はない、カスタムデリゲートにのみ関係する。

例:

auto interval = PosInfInterval!Date(Date(2010, 9, 1));
auto func = delegate (scope const Date date) //偶数日を反復処理する。
            {
                if ((date.day & 1) == 0)
                    return date + dur!"days"(2);

                return date + dur!"days"(1);
            };
auto range = interval.fwdRange(func);

//奇数日。PopFirst.yesを使えば、Date(2010, 9, 2)となる。
assert(range.front == Date(2010, 9, 1));

range.popFront();
assert(range.front == Date(2010, 9, 2));

range.popFront();
assert(range.front == Date(2010, 9, 4));

range.popFront();
assert(range.front == Date(2010, 9, 6));

range.popFront();
assert(range.front == Date(2010, 9, 8));

range.popFront();
assert(!range.empty);

const nothrow string toString();

この区間を文字列に変換する。

struct NegInfInterval(TP);

負の無限大を始点とする時間間隔を表す。を表す。

を反復する範囲はすべて無限大である。 NegInfIntervalを反復する範囲はすべて無限大である。したがってを使用する主な目的は NegInfIntervalを使う主な目的はを作成することである。それを逆に反復する。

pure nothrow this(scope const TP end);

Parameters:

TP end 区間を終了する時点。

例:

auto interval = PosInfInterval!Date(Date(1996, 1, 2));

pure nothrow ref NegInfInterval opAssign(const ref NegInfInterval rhs);

Parameters:

NegInfInterval rhs これに割り当てるNegInfInterval 。

pure nothrow ref NegInfInterval opAssign(NegInfInterval rhs);

Parameters:

NegInfInterval rhs これに割り当てるNegInfInterval 。

const pure nothrow @property TP end();

区間の終点。これは区間から除外される。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).end == Date(2012, 3, 1));

pure nothrow @property void end(TP timePoint);

区間の終点。区間から除外される。

Parameters:

TP timePoint 終了を設定する時点。

enum bool empty;

区間の長さが0かどうか。常にfalseを返す。

例:

assert(!NegInfInterval!Date(Date(1996, 1, 2)).empty);

const pure nothrow bool contains(TP timePoint);

与えられた時点がこの区間内にあるかどうか。

Parameters:

TP timePoint この区間に含まれるかどうかをチェックする時点。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).contains(Date(1994, 12, 24)));
assert(NegInfInterval!Date(Date(2012, 3, 1)).contains(Date(2000, 1, 5)));
assert(!NegInfInterval!Date(Date(2012, 3, 1)).contains(Date(2012, 3, 1)));

const pure bool contains(scope const Interval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

Parameters:

Interval!TP interval この区間に含まれるかどうかをチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).contains(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).contains(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).contains(
            Interval!Date(Date(1998, 2, 28), Date(2013, 5, 1))));

const pure nothrow bool contains(scope const PosInfInterval!TP interval);

与えられた区間が完全にこの区間内にあるかどうか。

負で始まる区間が正の無限大に向かう区間を含むことはあり得ないからである。

Parameters:

PosInfInterval!TP interval この区間に含まれるかどうかをチェックする区間。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).contains(
            PosInfInterval!Date(Date(1999, 5, 4))));

const pure nothrow bool contains(scope const NegInfInterval interval);

与えられた区間が完全にこの区間内にあるかどうか。

Parameters:

NegInfInterval interval この区間に含まれるかどうかをチェックする区間。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).contains(
            NegInfInterval!Date(Date(1996, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).contains(
            NegInfInterval!Date(Date(2013, 7, 9))));

const pure nothrow bool isBefore(scope const TP timePoint);

この区間が与えられた時点より前にあるかどうか。

Parameters:

TP timePoint この区間が指定された時点より前かどうかをチェックするより前かどうかをチェックする。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(Date(1994, 12, 24)));
assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(Date(2000, 1, 5)));
assert(NegInfInterval!Date(Date(2012, 3, 1)).isBefore(Date(2012, 3, 1)));

const pure bool isBefore(scope const Interval!TP interval);

この区間が与えられた区間より前にあり、区間と交差していないか。であるかどうか。

Parameters:

Interval!TP interval この区間に対してチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            Interval!Date(Date(2022, 10, 19), Date(2027, 6, 3))));

const pure nothrow bool isBefore(scope const PosInfInterval!TP interval);

この区間が与えられた区間より前にあり、かつ与えられた区間と交差していないかどうか。であるかどうか。

Parameters:

PosInfInterval!TP interval この区間に対してチェックする区間。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure nothrow bool isBefore(scope const NegInfInterval interval);

この区間が与えられた区間より前にありであるかどうか。

負ので始まる区間が、負ので始まる区間より前にあることはあり得ないからである。

Parameters:

NegInfInterval interval この区間に対してチェックする区間。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            NegInfInterval!Date(Date(1996, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isBefore(
            NegInfInterval!Date(Date(2013, 7, 9))));

const pure nothrow bool isAfter(scope const TP timePoint);

この間隔が指定された時点の後かどうか。

負の無限大から始まる区間はどの時点の後でもあり得ないので、常に偽を返す。から始まる区間は、どの時点の後でもあり得ないからである。

Parameters:

TP timePoint この区間がその時点より後にあるかどうかをチェックするための時点は、次のとおりである。である。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(Date(1994, 12, 24)));
assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(Date(2000, 1, 5)));
assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(Date(2012, 3, 1)));

const pure bool isAfter(scope const Interval!TP interval);

この区間が与えられた区間より後にあり、区間と交差していないかどうか。であるかどうか。

与えられた区間が空でない限り)常に偽を返す。なぜなら、負の無限大から始まる区間は、決して他の区間を返す。

Parameters:

Interval!TP interval この区間と照合する区間。

Throws:

std.datetime.date.DateTimeException与えられたインターバルが空の場合

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            Interval!Date(Date(2022, 10, 19), Date(2027, 6, 3))));

const pure nothrow bool isAfter(scope const PosInfInterval!TP interval);

この区間が与えられた区間より後にあり、交差していないかどうか。どうか。

負の無限大から始まる区間は、他の区間の後にはあり得ないので、常に偽を返す。から始まる区間は、他のどの区間の後にもあり得ないからである。

Parameters:

PosInfInterval!TP interval この区間と照合する区間。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure nothrow bool isAfter(scope const NegInfInterval interval);

この区間が与えられた区間より後にあり、かつ交差していないかどうか。どうか。

Parameters:

NegInfInterval interval この区間と照合する区間。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            NegInfInterval!Date(Date(1996, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAfter(
            NegInfInterval!Date(Date(2013, 7, 9))));

const pure bool intersects(scope const Interval!TP interval);

与えられたインターバルがこのインターバルに重なるかどうか。

Parameters:

Interval!TP interval この区間との交差をチェックする区間。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            Interval!Date(Date(1999, 1, 12), Date(2011, 9, 17))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            Interval!Date(Date(2022, 10, 19), Date(2027, 6, 3))));

const pure nothrow bool intersects(scope const PosInfInterval!TP interval);

与えられた区間がこの区間と重なっているかどうか。

Parameters:

PosInfInterval!TP interval この区間との交差をチェックするとの交差をチェックする区間。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure nothrow bool intersects(scope const NegInfInterval!TP interval);

与えられたインターバルがこのインターバルに重なるかどうか。

負の無限大から始まる2つの区間は常に重なるので、常に真を返す。で始まる2つの区間は常に重なるからである。

Parameters:

NegInfInterval!TP interval この区間との交差をチェックする区間。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            NegInfInterval!Date(Date(1996, 5, 4))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersects(
            NegInfInterval!Date(Date(2013, 7, 9))));

const Interval!TP intersection(scope const Interval!TP interval);

2つの区間の交点を返す

Parameters:

Interval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合、または与えられた区間が空の場合。

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       Interval!Date(Date(1990, 7 , 6), Date(2000, 8, 2)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            Interval!Date(Date(1999, 1, 12), Date(2015, 9, 2))) ==
       Interval!Date(Date(1999, 1 , 12), Date(2012, 3, 1)));

const Interval!TP intersection(scope const PosInfInterval!TP interval);

2つの区間の交点を返す

Parameters:

PosInfInterval!TP interval この区間と交差する区間

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差しない場合

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            PosInfInterval!Date(Date(1990, 7, 6))) ==
       Interval!Date(Date(1990, 7 , 6), Date(2012, 3, 1)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            PosInfInterval!Date(Date(1999, 1, 12))) ==
       Interval!Date(Date(1999, 1 , 12), Date(2012, 3, 1)));

const nothrow NegInfInterval intersection(scope const NegInfInterval interval);

2つの区間の交点を返す

Parameters:

NegInfInterval interval この区間と交差する区間

例:

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            NegInfInterval!Date(Date(1999, 7, 6))) ==
       NegInfInterval!Date(Date(1999, 7 , 6)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).intersection(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

const pure bool isAdjacent(scope const Interval!TP interval);

与えられた区間がこの区間に隣接するかどうか。

Parameters:

Interval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(1999, 1, 12), Date(2012, 3, 1))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(2012, 3, 1), Date(2019, 2, 2))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            Interval!Date(Date(2022, 10, 19), Date(2027, 6, 3))));

const pure nothrow bool isAdjacent(scope const PosInfInterval!TP interval);

与えられた区間がこの区間に隣接しているかどうか。

Parameters:

PosInfInterval!TP interval 指定された区間がこの区間に隣接しているかどうかをチェックするに隣接しているかどうかをチェックする。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            PosInfInterval!Date(Date(1999, 5, 4))));

assert(NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            PosInfInterval!Date(Date(2012, 3, 1))));

const pure nothrow bool isAdjacent(scope const NegInfInterval interval);

与えられた区間がこの区間に隣接しているかどうか。

負ので始まる2つの区間が隣接することはないため、常にfalseを返す。

Parameters:

NegInfInterval interval この区間に隣接するかどうかをチェックする区間に隣接しているかどうかをチェックする。

例:

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            NegInfInterval!Date(Date(1996, 5, 4))));

assert(!NegInfInterval!Date(Date(2012, 3, 1)).isAdjacent(
            NegInfInterval!Date(Date(2012, 3, 1))));

const NegInfInterval merge(scope const Interval!TP interval);

つの区間の共用体を返す。

Parameters:

Interval!TP interval この区間とマージする区間。

Throws:

std.datetime.date.DateTimeExceptionもし2つの区間がが交差せず隣接していない場合、または与えられた区間が空の場合。

注釈:」である。のオーバーロードはない。 mergeのオーバーロードはない。 PosInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(NegInfInterval!Date(Date(2012, 3, 1)).merge(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).merge(
            Interval!Date(Date(1999, 1, 12), Date(2015, 9, 2))) ==
       NegInfInterval!Date(Date(2015, 9 , 2)));

const pure nothrow NegInfInterval merge(scope const NegInfInterval interval);

2つの区間の"共用体"を返す。

Parameters:

NegInfInterval interval この区間とマージする区間。

注釈: 2つの区間をマージする。のオーバーロードはない。 mergeを取る PosInfInterval のオーバーロードはない。を取るオーバーロードは存在しない。はありえないからである。

例:」である。

assert(NegInfInterval!Date(Date(2012, 3, 1)).merge(
            NegInfInterval!Date(Date(1999, 7, 6))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).merge(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       NegInfInterval!Date(Date(2013, 1 , 12)));

const pure NegInfInterval span(scope const Interval!TP interval);

つの区間のうち最も古い時点から、2つの区間のうち最も遅い時点まで(を含まない)の区間を返す。の最も古い時点から、2つの区間区間を返す。

Parameters:

Interval!TP interval この区間である。

Throws:

std.datetime.date.DateTimeException与えられた区間が空の場合

注釈: のオーバーロードはない。 spanのオーバーロードはない。 PosInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(NegInfInterval!Date(Date(2012, 3, 1)).span(
            Interval!Date(Date(1990, 7, 6), Date(2000, 8, 2))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).span(
            Interval!Date(Date(1999, 1, 12), Date(2015, 9, 2))) ==
       NegInfInterval!Date(Date(2015, 9 , 2)));

assert(NegInfInterval!Date(Date(1600, 1, 7)).span(
            Interval!Date(Date(2012, 3, 11), Date(2017, 7, 1))) ==
       NegInfInterval!Date(Date(2017, 7 , 1)));

const pure nothrow NegInfInterval span(scope const NegInfInterval interval);

2つの区間のうち、最も古い時点から、最も古い時点まで(ただし 2つの区間の最も古い時点から、2つの区間の最も遅い時点までをカバーする区間を返す。区間を返す。

Parameters:

NegInfInterval interval この区間である。

注釈のオーバーロードはない。 spanを取る PosInfInterval のオーバーロードはない。を取るオーバーロードはない。はありえないからである。

例:」である。

assert(NegInfInterval!Date(Date(2012, 3, 1)).span(
            NegInfInterval!Date(Date(1999, 7, 6))) ==
       NegInfInterval!Date(Date(2012, 3 , 1)));

assert(NegInfInterval!Date(Date(2012, 3, 1)).span(
            NegInfInterval!Date(Date(2013, 1, 12))) ==
       NegInfInterval!Date(Date(2013, 1 , 12)));

pure nothrow void shift(D)(D duration) if (__traits(compiles, end + duration));

このインターバルのend を、指定された持続時間だけ時間的に前方または後方にシフトする。を前方または後方にシフトする(正の持続時間は間隔を前方にシフトし、負の持続時間は間隔を後方にシフトする)。負の場合は後ろにシフトする)。実質的には end += duration.

Parameters:

D duration で区間をシフトする。

例:

auto interval1 = NegInfInterval!Date(Date(2012, 4, 5));
auto interval2 = NegInfInterval!Date(Date(2012, 4, 5));

interval1.shift(dur!"days"(50));
assert(interval1 == NegInfInterval!Date(Date(2012, 5, 25)));

interval2.shift(dur!"days"(-50));
assert(interval2 == NegInfInterval!Date( Date(2012, 2, 15)));

void shift(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

この間隔のend を時間的に前方または後方にシフトする。指定された年数および/または月数(正の数 (正の年数および月数は間隔を前方にシフトし、負の数は後方にシフトする)。後方にシフトする)。指定された年月を加算して終了する。これはを効果的に呼び出す。 add!"years"()そして add!"months"() を呼び出す。

Parameters:

T `years`	間隔をずらす年数。
T `months`	間隔をずらす月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 end で、その月をインクリメントする。

Throws:

std.datetime.date.DateTimeExceptionemptyがtrueの場合、またはの場合、結果の間隔が無効となる。

例:」である。

auto interval1 = NegInfInterval!Date(Date(2012, 3, 1));
auto interval2 = NegInfInterval!Date(Date(2012, 3, 1));

interval1.shift(2);
assert(interval1 == NegInfInterval!Date(Date(2014, 3, 1)));

interval2.shift(-2);
assert(interval2 == NegInfInterval!Date(Date(2010, 3, 1)));

pure nothrow void expand(D)(D duration) if (__traits(compiles, end + duration));

区間を時間的に前方に拡大する。実質的には end += duration.

Parameters:

D duration で区間を拡大する。

例:

auto interval1 = NegInfInterval!Date(Date(2012, 3, 1));
auto interval2 = NegInfInterval!Date(Date(2012, 3, 1));

interval1.expand(dur!"days"(2));
assert(interval1 == NegInfInterval!Date(Date(2012, 3, 3)));

interval2.expand(dur!"days"(-2));
assert(interval2 == NegInfInterval!Date(Date(2012, 2, 28)));

void expand(T)(T years, T months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

区間を時間的に前方または後方に拡大する。効果的には指定された月/年数を追加する。

Parameters:

T `years`	区間を拡張する年数。
T `months`	間隔を拡張する月数。
AllowDayOverflow `allowOverflow`	日数をオーバーフローさせるかどうか。 end で、その月をインクリメントする。

Throws:

std.datetime.date.DateTimeExceptionemptyがtrueの場合、またはの場合、結果の間隔が無効となる。

例:」である。

auto interval1 = NegInfInterval!Date(Date(2012, 3, 1));
auto interval2 = NegInfInterval!Date(Date(2012, 3, 1));

interval1.expand(2);
assert(interval1 == NegInfInterval!Date(Date(2014, 3, 1)));

interval2.expand(-2);
assert(interval2 == NegInfInterval!Date(Date(2010, 3, 1)));

const NegInfIntervalRange!TP bwdRange(TP delegate(scope const TP) func, PopFirst popFirst = PopFirst.no);

区間を逆方向に反復する範囲を返す。 endを逆行する範囲を返す。を使用する。

もしfuncが範囲内の現在の。 front 以上の時点を生成することがあれば std.datetime.date.DateTimeExceptionがスローされる。

このモジュールには、一般的なデリゲートを生成するヘルパー関数がある。に渡す一般的なデリゲートを生成するヘルパー関数がある。 bwdRange.それらのドキュメントは "範囲生成関数"で始まる。

Parameters:

TP delegate(scope const TP) `func`	区間の時点を生成するために使われる関数である。を生成するために使用される関数。
PopFirst `popFirst`	popFront を返す前にを呼び出すかどうか。

Throws:

std.datetime.date.DateTimeExceptionこの区間がが空の場合。

もちろん、このモジュールのどの関数にもこの問題はない、カスタムデリゲートにのみ関係する。

例:

auto interval = NegInfInterval!Date(Date(2010, 9, 9));
auto func = delegate (scope const Date date) //偶数日を反復処理する。
            {
                if ((date.day & 1) == 0)
                    return date - dur!"days"(2);

                return date - dur!"days"(1);
            };
auto range = interval.bwdRange(func);

assert(range.front == Date(2010, 9, 9)); //奇数日。PopFirst.yesを使えば、Date(2010, 9, 8)となる。

range.popFront();
assert(range.front == Date(2010, 9, 8));

range.popFront();
assert(range.front == Date(2010, 9, 6));

range.popFront();
assert(range.front == Date(2010, 9, 4));

range.popFront();
assert(range.front == Date(2010, 9, 2));

range.popFront();
assert(!range.empty);

const nothrow string toString();

この区間を文字列に変換する。

nothrow TP delegate(scope const TP) everyDayOfWeek(TP, Direction dir = Direction.fwd)(DayOfWeek dayOfWeek) if (isTimePoint!TP && (dir == Direction.fwd || dir == Direction.bwd) && __traits(hasMember, TP, "dayOfWeek") && !__traits(isStaticFunction, TP.dayOfWeek) && is(typeof(TP.dayOfWeek) == DayOfWeek));

範囲生成関数。

を持つ次の時点を返すデリゲートを返す。 DayOfWeek を持つ次の時点を返すデリゲートを返す。

このデリゲートを使うことで、すべて同じ曜日である例えば、DayOfWeek.mon を everyDayOfWeekを渡すと、次のようなデリゲートになる。デリゲートとなる。

Parameters:

dir	イテレートする方向。に戻り値を渡す場合は、を使用する。 fwdRange に渡す場合は、Direction.fwd を使う。に渡す場合は bwdRange に渡す場合は、Direction.bwd を使用する。
DayOfWeek `dayOfWeek`	範囲内の各時点が属する週。

Examples:

import std.datetime.date : Date, DayOfWeek;

auto interval = Interval!Date(Date(2010, 9, 2), Date(2010, 9, 27));
auto func = everyDayOfWeek!Date(DayOfWeek.mon);
auto range = interval.fwdRange(func);

// 木曜日。PopFirst.yesを使えば、Date(2010, 9, 6)となる。
writeln(range.front); // Date(2010, 9, 2)

range.popFront();
writeln(range.front); // Date(2010, 9, 6)

range.popFront();
writeln(range.front); // Date(2010, 9, 13)

range.popFront();
writeln(range.front); // Date(2010, 9, 20)

range.popFront();
assert(range.empty);

TP delegate(scope const TP) everyMonth(TP, Direction dir = Direction.fwd)(int month) if (isTimePoint!TP && (dir == Direction.fwd || dir == Direction.bwd) && __traits(hasMember, TP, "month") && !__traits(isStaticFunction, TP.month) && is(typeof(TP.month) == Month));

レンジ生成機能。

与えられた月がある次の時点を返すデリゲートを返す。を持つ次の時点を返すデリゲートを返す。

つまり、このデリゲートを使うことで、同じ月でありながら異なる年であるつまり、このデリゲートを使うことで、同じ月で年が異なる連続した時点を反復することができる。例:"、を開始し、。で開始し、Month.dec 。 everyMonthに渡してデリゲートを作成する。

特定の月を反復処理するのはあまり意味がない。特定の月を繰り返し、その次の月や前の時点から2年後の時点で終了するのは、あまり意味がないからだ。次の時点を計算するときには、常にAllowDayOverflow.no 。を使用する。

Parameters:

dir	イテレートする方向。に戻り値を渡す場合は、を使用する。 fwdRange に渡す場合は、Direction.fwd を使う。に渡す場合は bwdRange に渡す場合は、Direction.bwd を使用する。
int `month`	範囲内の各時点が属する月。 (になる(1月は1)。

Examples:

import std.datetime.date : Date, Month;

auto interval = Interval!Date(Date(2000, 1, 30), Date(2004, 8, 5));
auto func = everyMonth!Date(Month.feb);
auto range = interval.fwdRange(func);

// PopFirst.yesを使えば、Date(2010, 2, 29)となる。
writeln(range.front); // Date(2000, 1, 30)

range.popFront();
writeln(range.front); // Date(2000, 2, 29)

range.popFront();
writeln(range.front); // Date(2001, 2, 28)

range.popFront();
writeln(range.front); // Date(2002, 2, 28)

range.popFront();
writeln(range.front); // Date(2003, 2, 28)

range.popFront();
writeln(range.front); // Date(2004, 2, 28)

range.popFront();
assert(range.empty);

nothrow TP delegate(return scope const TP) everyDuration(TP, Direction dir = Direction.fwd, D)(D duration) if (isTimePoint!TP && __traits(compiles, TP.init + duration) && (dir == Direction.fwd || dir == Direction.bwd));

レンジ生成機能。

与えられた持続時間の次の時点を返すデリゲートを返す。期間後である次の時点を返すデリゲートを返す。

このデリゲートを使用することで、指定された期間だけ離れた連続した時点に対する反復が可能になる。たとえば、dur!"days"(3) を everyDurationを渡すと、次のようなデリゲートになる。デリゲートとなる。

Parameters:

dir	イテレートする方向。に戻り値を渡す場合は、を使用する。 fwdRange に渡す場合は、Direction.fwd を使う。に渡す場合は bwdRange に渡す場合は、Direction.bwd を使用する。
D `duration`	範囲内の連続する各時点を区切る期間。である。

Examples:

import core.time : dur;
import std.datetime.date : Date;

auto interval = Interval!Date(Date(2010, 9, 2), Date(2010, 9, 27));
auto func = everyDuration!Date(dur!"days"(8));
auto range = interval.fwdRange(func);

// PopFirst.yesを使えば、Date(2010, 9, 10)となる。
writeln(range.front); // Date(2010, 9, 2)

range.popFront();
writeln(range.front); // Date(2010, 9, 10)

range.popFront();
writeln(range.front); // Date(2010, 9, 18)

range.popFront();
writeln(range.front); // Date(2010, 9, 26)

range.popFront();
assert(range.empty);

nothrow TP delegate(scope const TP) everyDuration(TP, Direction dir = Direction.fwd, D)(int years, int months = 0, AllowDayOverflow allowOverflow = AllowDayOverflow.yes, D duration = dur!"days"(0)) if (isTimePoint!TP && __traits(compiles, TP.init + duration) && __traits(compiles, TP.init.add!"years"(years)) && __traits(compiles, TP.init.add!"months"(months)) && (dir == Direction.fwd || dir == Direction.bwd));

レンジ生成機能。

与えられた年数、月数、期間の次の時点を返すデリゲートを返す。である次の時点を返すデリゲートを返す。

このバージョンの everyDurationのこのバージョンととの違いは core.time.Durationを取るバージョンとの違いは AllowDayOverflow を取ることである。がついている)。

順方向に反復する場合、この関数が呼び出される、 add!"years"()が与えられたが呼び出され add!"months"()となり、最後に持続時間が追加される。しかし、順方向に反復する場合は、まず持続時間が追加され、次に add!"months"()が呼ばれ、最後に add!"years"()が呼ばれる。そうすることで、後方への反復は前方への反復とほぼ同じ時間ポイントを生成する。しかし、年月の追加は完全には可逆的ではない(日数がオーバーフローする可能性があるため)。を使うかどうかに関係なく、日数がオーバーフローする可能性があるため)。 AllowDayOverflow.yes またはAllowDayOverflow.no )に関係なく、日のオーバーフローの可能性があるため)。後方への反復が前方への反復と同じ時点を与えることは保証できない。と同じ時点を返すという保証はない。であると仮定しても)。 begin )。

Parameters:

dir	イテレートする方向。戻り値を fwdRange を渡す場合は、Direction.fwd を使用する。もし bwdRange に渡す場合は、Direction.bwd を使用する。
int `years`	デリゲートに渡された時点に追加する年数。デリゲートに渡されるタイムポイントに追加する年数。
int `months`	デリゲートに渡されたタイムポイントに追加する月数。を指定する。
AllowDayOverflow `allowOverflow`	で日数をオーバーフローさせるかどうか。 begin およびend 。インクリメントする。
D `duration`	デリゲートに渡されたタイムポイントに追加する期間。デリゲートに渡されるタイムポイントに追加する期間。

Examples:

import core.time : dur;
import std.datetime.date : AllowDayOverflow, Date;

auto interval = Interval!Date(Date(2010, 9, 2), Date(2025, 9, 27));
auto func = everyDuration!Date(4, 1, AllowDayOverflow.yes, dur!"days"(2));
auto range = interval.fwdRange(func);

// PopFirst.yesを使えば、Date(2014, 10, 12)となる。
writeln(range.front); // Date(2010, 9, 2)

range.popFront();
writeln(range.front); // Date(2014, 10, 4)

range.popFront();
writeln(range.front); // Date(2018, 11, 6)

range.popFront();
writeln(range.front); // Date(2022, 12, 8)

range.popFront();
assert(range.empty);

struct IntervalRange(TP, Direction dir) if (isTimePoint!TP && (dir != Direction.both));

範囲 Interval.

IntervalRangeによってのみ構築される。 Interval.によってのみ構築される。によってのみ構築されるが、構築されるとき、func という関数が与えられる。 func 。を受け取り、同じ型の時間点を返す。例えばのすべての日数を反復処理するには Interval!Date に関数を渡す。 Interval's fwdRange に関数を渡す。 std.datetime.date.Dateを取りを返す。 std.datetime.date.Dateを返す。そのその関数は、次のように使われる。 IntervalRangeのpopFront 。を繰り返す。 std.datetime.date.Dateを反復する。

dir == Direction.fwd の場合、範囲は時間的に前方に反復される。がdir == Direction.bwd の場合は、時間的に後方に反復される。したがって、もし dir == Direction.fwd なら、front == interval.begin 。 dir == Direction.bwd func なら、front == interval.end 。は、反復の適切な方向に向かう時点を生成しなければならない。 std.datetime.date.DateTimeExceptionがスローされる。つまり、時間的に前方に反復するには前方へ反復するためには、func が生成する時点は、渡された時点より時間的に後でなければならない。でなければならない。もしそれが同じか時間的に早いなら、、がスローされる。 std.datetime.date.DateTimeExceptionがスローされる。を投げる。をスローする。より前でなければならない。

もし生成された時点が、適切な方向の範囲の端を通過することがあれば、その範囲の端が代わりに使われる。もし生成された時点が適切な方向の範囲の端を通過することがあれば、その範囲の端が代わりに使われる。つまりを繰り返し、生成された時点がその区間の端を過ぎた場合、はになる。 end を過ぎた場合、front はend になる。後方へ反復し生成された時点がbegin の前である場合、front は次のようになる。 begin.どちらの場合も、範囲は空になる。

また、通常、ある区間のbegin はその中に含まれ、はその中から除外される。 dir == Direction.bwd に含まれ、end はそこから除外される。 begin は除外され、end は含まれるものとして扱われる。これによりは両方向で同じ動作を可能にする。これは Intervalの関数のどれもが、begin またはend によって呼び出されることはない。 IntervalRange.interval が呼び出されることはないからである。dir == Direction.fwd またはdir == Direction.bwd 。 Intervalによって呼び出される。によって呼び出された関数は、begin またはend が含まれるか除外されるかに関係なく、通常の区間を返す。を気にする関数は、begin を含むものとして扱い、end を含まないものとして扱う。

pure nothrow ref IntervalRange opAssign(ref IntervalRange rhs); pure nothrow ref IntervalRange opAssign(IntervalRange rhs);

Parameters:

IntervalRange rhs この関数に代入するIntervalRange 。

const pure nothrow @property bool empty();

このIntervalRange が空かどうか。

const pure @property TP front();

範囲内の最初の時点。

Throws:

std.datetime.date.DateTimeException範囲が空の場合。

void popFront();

front func を使って範囲内の次の時点を生成する。を使用して、範囲内の次の時点を生成する。生成された時点が範囲の端を越えている場合生成された時点が範囲の端を越えている場合、がその端に設定され、範囲は空になる。は空になる。したがって、順方向に反復して、生成された時点がよりも大きい場合、が設定される。 .後方に反復し、生成された時点が区間よりも小さい場合は、がセットされる。より小さい場合、はにセットされる。 front end front end begin front begin

Throws:

std.datetime.date.DateTimeException範囲が空の場合に設定される。範囲が空である場合、または生成された時点が誤った方向である場合(すなわち順方向に繰り返し、生成された時点がfront 、の後にある場合など)。 front).

pure nothrow @property IntervalRange save();

this のコピーを返す。

const pure nothrow @property Interval!TP interval();

このIntervalRange が現在カバーしている区間。

pure nothrow @property TP delegate(scope const TP) func();

範囲内の次の時点を生成するために使用される関数。

const pure nothrow @property Direction direction();

この範囲が反復するDirection 。

struct PosInfIntervalRange(TP) if (isTimePoint!TP);

PosInfInterval 上の範囲。無限範囲である。

PosInfIntervalRangeはPosInfInterval によってのみ構築される。によってのみ構築される。しかし、構築されるとき、func という関数が与えられる。は、反復される時点を生成するために使用される。func は時間点を取り、同じ型の時間点を返す。例えば例えば PosInfInterval!Date を渡す。関数をPosInfInterval のfwdRange に渡す。 std.datetime.date.Dateを取り std.datetime.date.Date を返す。その関数は次のように使われる。 PosInfIntervalRangeのpopFront 。 std.datetime.date.Dateしかし、明らかに範囲は無限なので、すべての日付を反復するのではなく、std.range.take のような関数を使う。のような関数を使う。

区間が正の無限大になるにつれて、範囲は常に順方向に反復され、逆方向に反復されることはない。 func 、反復の適切な方向に向かう時点を生成しなければならない。を生成しなければならない。 std.datetime.date.DateTimeExceptionがスローされる。したがって、が生成するしたがって、func が生成する時点は、渡された時点より後の時点でなければならない。より後でなければならない。もしそれが同じか時間的に早い場合、。 std.datetime.date.DateTimeExceptionがスローされる。

pure nothrow ref PosInfIntervalRange opAssign(ref PosInfIntervalRange rhs); pure nothrow ref PosInfIntervalRange opAssign(PosInfIntervalRange rhs);

Parameters:

PosInfIntervalRange rhs PosInfIntervalRange 。

enum bool empty;

これは無限の範囲なので、空になることはない。

const pure nothrow @property TP front();

範囲内の最初の時点。

void popFront();

範囲内の最初の時点。front を範囲からポップし、func を使って範囲内の次の時点を生成する。範囲内の次の時点を生成する。

Throws:

std.datetime.date.DateTimeException生成された時点ががfront よりも小さい場合。

pure nothrow @property PosInfIntervalRange save();

this のコピーを返す。

const pure nothrow @property PosInfInterval!TP interval();

この範囲が現在カバーしている区間。

pure nothrow @property TP delegate(scope const TP) func();

範囲内の次の時点を生成するために使用される関数。

struct NegInfIntervalRange(TP) if (isTimePoint!TP);

NegInfInterval 上の範囲。無限範囲である。

NegInfIntervalRangeはNegInfInterval によってのみ構築される。によってのみ構築される。しかし、構築されるときには、func という関数が与えられる。は、反復される時点を生成するために使用される。func は時間点を取り、同じ型の時間点を返す。例えばに関数を渡す。 NegInfInterval!Date NegInfInterval に関数を渡す。 bwdRange に関数を渡す。 std.datetime.date.Dateを取りを返す。 std.datetime.date.Dateを返す。そのその関数は、次のように使われる。 NegInfIntervalRangeのpopFront 。を反復する。 std.datetime.date.Dateしかし明らかに、範囲は無限なので、すべての日付を反復するのではなく、次のような関数を使う。 std.range.take のような関数を使う。

区間が負の無限大になるにつれて、範囲は常に逆方向へ反復される。 func 、反復の適切な方向に向かう時点を生成しなければならない。を生成しなければならない。 std.datetime.date.DateTimeExceptionがスローされる。したがって、が生成するしたがって、func が生成する時点は、渡された時点よりも早い時点でなければならない。よりも早いものでなければならない。もしそれが同じか時間的に遅いなら std.datetime.date.DateTimeExceptionがスローされる。

また、通常、区間end 。から除外される、 NegInfIntervalRangeはそれを含むものとして扱う。これにより PosInfIntervalRange と同じ動作をする。これはというのも、NegInfInterval の関数のうち、includeかexcludeかを気にする関数は一つもないからである。 end によって呼び出されることはない。 NegInfIntervalRangeinterval は通常の区間を返す。 NegInfInterval によって呼び出されることはないからである。 end が含まれるか除外されるかを気にする関数は、end を除外されたものとして扱う。

pure nothrow ref NegInfIntervalRange opAssign(ref NegInfIntervalRange rhs); pure nothrow ref NegInfIntervalRange opAssign(NegInfIntervalRange rhs);

Parameters:

NegInfIntervalRange rhs これに代入するNegInfIntervalRange 。

enum bool empty;

これは無限範囲なので、空になることはない。

const pure nothrow @property TP front();

範囲内の最初の時点。

void popFront();

front func を使って範囲内の次の時点を生成する。範囲内の次の時点を生成する。

Throws:

std.datetime.date.DateTimeException生成された時点ががfront より大きい場合。

pure nothrow @property NegInfIntervalRange save();

this のコピーを返す。

const pure nothrow @property NegInfInterval!TP interval();

この範囲が現在カバーしている区間。

pure nothrow @property TP delegate(scope const TP) func();

範囲内の次の時点を生成するために使用される関数。

DEEPL APIにより翻訳、ところどころ修正。
このページの最新版(英語)
このページの原文(英語)
翻訳時のdmdのバージョン: 2.108.0
ドキュメントのdmdのバージョン: 2.109.1
翻訳日付 :2024-04-15 10:57:24+09:00
HTML生成日時: 2025-01-09 08:11:51+09:00
編集者: dokutoku

言語リファレンス

std.datetime.interval