Library Reference

version 2.112.0

Internal API

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page.Requires a signed-in GitHub account. This works well for small changes.If you'd like to make larger changes you may want to consider usinga local clone.

std.datetime.interval


Category	Functions
Main types	Interval Direction
Special intervals	everyDayOfWeek everyMonth everyDuration
Special intervals	NegInfInterval PosInfInterval
Underlying ranges	IntervalRange NegInfIntervalRange PosInfIntervalRange
Flags	PopFirst

License:

Boost License 1.0.

Authors:

Jonathan M Davis

Sourcestd/datetime/interval.d

enumDirection: int;

Indicates a direction in time. One example of its use isInterval'sexpand function which uses it to indicate whether the interval should be expanded backwards (into the past), forwards (into the future), or both.

bwd: Backward.
fwd: Forward.
both: Both backward and forward.

aliasPopFirst = std.typecons.Flag!"popFirst".Flag;

Used to indicate whetherpopFront should be called immediately upon creating a range. The idea is that for some functions used to generate a range for an interval,front is not necessarily a time point which would ever be generated by the range (e.g. if the range were every Sunday within an interval, but the interval started on a Monday), so there needs to be a way to deal with that. To get the first time point in the range to match what the function generates, then usePopFirst.yes to indicate that the range should havepopFront called on it before the range is returned so thatfront is a time point which the function would generate. To let the first time point not match the generator function, usePopFront.no.

For instance, if the function used to generate a range of time points generated successive Easters (i.e. you're iterating over all of the Easters within the interval), the initial date probably isn't an Easter. UsingPopFirst.yes would tell the function which returned the range thatpopFront was to be called so that front would then be an Easter - the next one generated by the function (which when iterating forward would be the Easter following the originalfront, while when iterating backward, it would be the Easter prior to the originalfront). IfPopFirst.no were used, thenfront would remain the original time point and it would not necessarily be a time point which would be generated by the range-generating function (which in many cases is exactly what is desired - e.g. if iterating over every day starting at the beginning of the interval).

If set toPopFirst.no, then popFront is not called before returning the range.

Otherwise, if set toPopFirst.yes, then popFront is called before returning the range.

structInterval(TP);

Represents an interval of time.

AnInterval has a starting point and an end point. The interval of time is therefore the time starting at the starting point up to, but not including, the end point. e.g.


[January 5th, 2010 - March 10th, 2010)
[05:00:30 - 12:00:00)
[1982-01-04T08:59:00 - 2010-07-04T12:00:00)

A range can be obtained from anInterval, allowing iteration over that interval, with the exact time points which are iterated over depending on the function which generates the range.

pure this(U)(scope const TPbegin, scope const Uend) if (is(immutable(TP) == immutable(U)));

Parameters:

TP`begin`	The time point which begins the interval.
U`end`	The time point which ends (but is not included in) the interval.

Throws:

std.datetime.date.DateTimeException ifend is beforebegin.

Example

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

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

Parameters:

TP`begin`	The time point which begins the interval.
D`duration`	The duration from the starting point to the end point.

Throws:

std.datetime.date.DateTimeException if the resultingend is beforebegin.

Example

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

pure nothrow ref IntervalopAssign(ref const Intervalrhs);

Parameters:

Intervalrhs TheInterval to assign to this one.

pure nothrow ref IntervalopAssign(Intervalrhs);

Parameters:

Intervalrhs TheInterval to assign to this one.

pure nothrow @property TPbegin() const;

The starting point of the interval. It is included in the interval.

Example

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

pure @property voidbegin(TPtimePoint);

The starting point of the interval. It is included in the interval.

Parameters:

TPtimePoint The time point to setbegin to.

Throws:

std.datetime.date.DateTimeException if the resulting interval would be invalid.

pure nothrow @property TPend() const;

The end point of the interval. It is excluded from the interval.

Example

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

pure @property voidend(TPtimePoint);

The end point of the interval. It is excluded from the interval.

Parameters:

TPtimePoint The time point to set end to.

Throws:

std.datetime.date.DateTimeException if the resulting interval would be invalid.

pure nothrow @property autolength() const;

Returns the duration betweenbegin andend.

Example

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

pure nothrow @property boolempty() const;

Whether the interval's length is 0, that is, whetherbegin == end.

Example

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

pure boolcontains(scope const TPtimePoint) const;

Whether the given time point is within this interval.

Parameters:

TPtimePoint The time point to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolcontains(scope const Intervalinterval) const;

Whether the given interval is completely within this interval.

Parameters:

Intervalinterval The interval to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure boolcontains(scope const PosInfInterval!TPinterval) const;

Whether the given interval is completely within this interval.

Always returns false (unless this interval is empty), because an interval going to positive infinity can never be contained in a finite interval.

Parameters:

PosInfInterval!TPinterval The interval to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolcontains(scope const NegInfInterval!TPinterval) const;

Whether the given interval is completely within this interval.

Always returns false (unless this interval is empty), because an interval beginning at negative infinity can never be contained in a finite interval.

Parameters:

NegInfInterval!TPinterval The interval to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisBefore(scope const TPtimePoint) const;

Whether this interval is before the given time point.

Parameters:

TPtimePoint The time point to check whether this interval is before it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisBefore(scope const Intervalinterval) const;

Whether this interval is before the given interval and does not intersect with it.

Parameters:

Intervalinterval The interval to check for against this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure boolisBefore(scope const PosInfInterval!TPinterval) const;

Whether this interval is before the given interval and does not intersect with it.

Parameters:

PosInfInterval!TPinterval The interval to check for against this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisBefore(scope const NegInfInterval!TPinterval) const;

Whether this interval is before the given interval and does not intersect with it.

Always returns false (unless this interval is empty) because a finite interval can never be before an interval beginning at negative infinity.

Parameters:

NegInfInterval!TPinterval The interval to check for against this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisAfter(scope const TPtimePoint) const;

Whether this interval is after the given time point.

Parameters:

TPtimePoint The time point to check whether this interval is after it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisAfter(scope const Intervalinterval) const;

Whether this interval is after the given interval and does not intersect it.

Parameters:

Intervalinterval The interval to check against this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure boolisAfter(scope const PosInfInterval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Always returns false (unless this interval is empty) because a finite interval can never be after an interval going to positive infinity.

Parameters:

PosInfInterval!TPinterval The interval to check against this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisAfter(scope const NegInfInterval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Parameters:

NegInfInterval!TPinterval The interval to check against this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolintersects(scope const Intervalinterval) const;

Whether the given interval overlaps this interval.

Parameters:

Intervalinterval The interval to check for intersection with this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure boolintersects(scope const PosInfInterval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

PosInfInterval!TPinterval The interval to check for intersection with this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolintersects(scope const NegInfInterval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

NegInfInterval!TPinterval The interval to check for intersection with this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

Intervalintersection(scope const Intervalinterval) const;

Returns the intersection of two intervals

Parameters:

Intervalinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect or if either interval is empty.

Example

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

Intervalintersection(scope const PosInfInterval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

PosInfInterval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect or if this interval is empty.

Example

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

Intervalintersection(scope const NegInfInterval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

NegInfInterval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect or if this interval is empty.

Example

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

pure boolisAdjacent(scope const Intervalinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

Intervalinterval The interval to check whether its adjecent to this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure boolisAdjacent(scope const PosInfInterval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

PosInfInterval!TPinterval The interval to check whether its adjecent to this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure boolisAdjacent(scope const NegInfInterval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

NegInfInterval!TPinterval The interval to check whether its adjecent to this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

Intervalmerge(scope const Intervalinterval) const;

Returns the union of two intervals

Parameters:

Intervalinterval The interval to merge with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect and are not adjacent or if either interval is empty.

Example

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

PosInfInterval!TPmerge(scope const PosInfInterval!TPinterval) const;

Returns the union of two intervals

Parameters:

PosInfInterval!TPinterval The interval to merge with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect and are not adjacent or if this interval is empty.

Example

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

NegInfInterval!TPmerge(scope const NegInfInterval!TPinterval) const;

Returns the union of two intervals

Parameters:

NegInfInterval!TPinterval The interval to merge with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect and are not adjacent or if this interval is empty.

Example

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

pure Intervalspan(scope const Intervalinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

Intervalinterval The interval to create a span together with this interval.

Throws:

std.datetime.date.DateTimeException if either interval is empty.

Example

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

pure PosInfInterval!TPspan(scope const PosInfInterval!TPinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

PosInfInterval!TPinterval The interval to create a span together with this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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

pure NegInfInterval!TPspan(scope const NegInfInterval!TPinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

NegInfInterval!TPinterval The interval to create a span together with this interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Example

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 voidshift(D)(Dduration) if (__traits(compiles, begin +duration));

Shifts the interval forward or backwards in time by the given duration (a positive duration shifts the interval forward; a negative duration shifts it backward). Effectively, it doesbegin += duration andend += duration.

Parameters:

Dduration The duration to shift the interval by.

Throws:

std.datetime.date.DateTimeException this interval is empty or if the resulting interval would be invalid.

Example

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

voidshift(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

Shifts the interval forward or backwards in time by the given number of years and/or months (a positive number of years and months shifts the interval forward; a negative number shifts it backward). It adds the years the given years and months to both begin and end. It effectively callsadd!"years"() and thenadd!"months"() on begin and end with the given number of years and months.

Parameters:

T`years`	The number of years to shift the interval by.
T`months`	The number of months to shift the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onbegin andend, causing their month to increment.

Throws:

std.datetime.date.DateTimeException if this interval is empty or if the resulting interval would be invalid.

Example

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 voidexpand(D)(Dduration, Directiondir = Direction.both) if (__traits(compiles, begin +duration));

Expands the interval forwards and/or backwards in time. Effectively, it doesbegin -= duration and/orend += duration. Whether it expands forwards and/or backwards in time is determined bydir.

Parameters:

D`duration`	The duration to expand the interval by.
Direction`dir`	The direction in time to expand the interval.

Throws:

std.datetime.date.DateTimeException this interval is empty or if the resulting interval would be invalid.

Example

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

voidexpand(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes, Directiondir = Direction.both) if (isIntegral!T);

Expands the interval forwards and/or backwards in time. Effectively, it subtracts the given number of months/years frombegin and adds them toend. Whether it expands forwards and/or backwards in time is determined bydir.

Parameters:

T`years`	The number of years to expand the interval by.
T`months`	The number of months to expand the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onbegin andend, causing their month to increment.
Direction`dir`	The direction in time to expand the interval.

Throws:

std.datetime.date.DateTimeException if this interval is empty or if the resulting interval would be invalid.

Example

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

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

Returns a range which iterates forward over the interval, starting atbegin, usingfunc to generate each successive time point.

The range'sfront is the interval'sbegin.func is used to generate the nextfront whenpopFront is called. IfpopFirst isPopFirst.yes, thenpopFront is called before the range is returned (so thatfront is a time point whichfunc would generate).

Iffunc ever generates a time point less than or equal to the currentfront of the range, then astd.datetime.date.DateTimeException will be thrown. The range will be empty and iteration complete whenfunc generates a time point equal to or beyond theend of the interval.

There are helper functions in this module which generate common delegates to pass tofwdRange. Their documentation starts with "Range-generating function," making them easily searchable.

Parameters:

TP delegate(scope const TP)`func`	The function used to generate the time points of the range over the interval.
PopFirst`popFirst`	WhetherpopFront should be called on the range before returning it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Warningfunc must be logically pure. Ideally,func would be a function pointer to a pure function, but forcingfunc to be pure is far too restrictive to be useful, and in order to have the ease of use of having functions which generate functions to pass tofwdRange,func must be a delegate.

Iffunc retains state which changes as it is called, then some algorithms will not work correctly, because the range'ssave will have failed to have really saved the range's state. To avoid such bugs, don't pass a delegate which is not logically pure tofwdRange. Iffunc is given the same time point with two different calls, it must return the same result both times.

Of course, none of the functions in this module have this problem, so it's only relevant if when creating a custom delegate.

Example

auto interval = Interval!Date(Date(2010, 9, 1), Date(2010, 9, 9));autofunc =delegate (scopeconst Date date)// For iterating over even-numbered days.            {if ((date.day & 1) == 0)return date + dur!"days"(2);return date + dur!"days"(1);            };auto range = interval.fwdRange(func);// An odd day. Using PopFirst.yes would have made this 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);

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

Returns a range which iterates backwards over the interval, starting atend, usingfunc to generate each successive time point.

The range'sfront is the interval'send.func is used to generate the nextfront whenpopFront is called. IfpopFirst isPopFirst.yes, thenpopFront is called before the range is returned (so thatfront is a time point whichfunc would generate).

Iffunc ever generates a time point greater than or equal to the currentfront of the range, then astd.datetime.date.DateTimeException will be thrown. The range will be empty and iteration complete whenfunc generates a time point equal to or less than thebegin of the interval.

There are helper functions in this module which generate common delegates to pass tobwdRange. Their documentation starts with "Range-generating function," making them easily searchable.

Parameters:

TP delegate(scope const TP)`func`	The function used to generate the time points of the range over the interval.
PopFirst`popFirst`	WhetherpopFront should be called on the range before returning it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Iffunc retains state which changes as it is called, then some algorithms will not work correctly, because the range'ssave will have failed to have really saved the range's state. To avoid such bugs, don't pass a delegate which is not logically pure tofwdRange. Iffunc is given the same time point with two different calls, it must return the same result both times.

Of course, none of the functions in this module have this problem, so it's only relevant for custom delegates.

Example

auto interval = Interval!Date(Date(2010, 9, 1), Date(2010, 9, 9));autofunc =delegate (scopeconst Date date)// For iterating over even-numbered days.            {if ((date.day & 1) == 0)return date - dur!"days"(2);return date - dur!"days"(1);            };auto range = interval.bwdRange(func);// An odd day. Using PopFirst.yes would have made this 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);

nothrow @safe stringtoString() const; voidtoString(Writer)(ref Writerw) const if (isOutputRange!(Writer, char));

Converts this interval to a string.

Parameters:

Writerw Achar acceptingoutput range

Returns:

Astring when not using an output range;void otherwise.

structPosInfInterval(TP);

Represents an interval of time which has positive infinity as its end point.

Any ranges which iterate over aPosInfInterval are infinite. So, the main purpose of usingPosInfInterval is to create an infinite range which starts at a fixed point in time and goes to positive infinity.

pure nothrow this(scope const TPbegin);

Parameters:

TPbegin The time point which begins the interval.

Example

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

pure nothrow ref PosInfIntervalopAssign(ref const PosInfIntervalrhs);

Parameters:

PosInfIntervalrhs ThePosInfInterval to assign to this one.

pure nothrow ref PosInfIntervalopAssign(PosInfIntervalrhs);

Parameters:

PosInfIntervalrhs ThePosInfInterval to assign to this one.

pure nothrow @property TPbegin() const;

The starting point of the interval. It is included in the interval.

Example

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

pure nothrow @property voidbegin(TPtimePoint);

The starting point of the interval. It is included in the interval.

Parameters:

TPtimePoint The time point to setbegin to.

enum boolempty;

Whether the interval's length is 0. Always returns false.

Example

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

pure nothrow boolcontains(TPtimePoint) const;

Whether the given time point is within this interval.

Parameters:

TPtimePoint The time point to check for inclusion in this interval.

Example

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

pure boolcontains(scope const Interval!TPinterval) const;

Whether the given interval is completely within this interval.

Parameters:

Interval!TPinterval The interval to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolcontains(scope const PosInfIntervalinterval) const;

Whether the given interval is completely within this interval.

Parameters:

PosInfIntervalinterval The interval to check for inclusion in this interval.

Example

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

pure nothrow boolcontains(scope const NegInfInterval!TPinterval) const;

Whether the given interval is completely within this interval.

Always returns false because an interval going to positive infinity can never contain an interval beginning at negative infinity.

Parameters:

NegInfInterval!TPinterval The interval to check for inclusion in this interval.

Example

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

pure nothrow boolisBefore(scope const TPtimePoint) const;

Whether this interval is before the given time point.

Always returns false because an interval going to positive infinity can never be before any time point.

Parameters:

TPtimePoint The time point to check whether this interval is before it.

Example

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

pure boolisBefore(scope const Interval!TPinterval) const;

Whether this interval is before the given interval and does not intersect it.

Always returns false (unless the given interval is empty) because an interval going to positive infinity can never be before any other interval.

Parameters:

Interval!TPinterval The interval to check for against this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolisBefore(scope const PosInfIntervalinterval) const;

Whether this interval is before the given interval and does not intersect it.

Always returns false because an interval going to positive infinity can never be before any other interval.

Parameters:

PosInfIntervalinterval The interval to check for against this interval.

Example

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

pure nothrow boolisBefore(scope const NegInfInterval!TPinterval) const;

Whether this interval is before the given interval and does not intersect it.

Always returns false because an interval going to positive infinity can never be before any other interval.

Parameters:

NegInfInterval!TPinterval The interval to check for against this interval.

Example

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

pure nothrow boolisAfter(scope const TPtimePoint) const;

Whether this interval is after the given time point.

Parameters:

TPtimePoint The time point to check whether this interval is after it.

Example

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

pure boolisAfter(scope const Interval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Parameters:

Interval!TPinterval The interval to check against this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolisAfter(scope const PosInfIntervalinterval) const;

Whether this interval is after the given interval and does not intersect it.

Always returns false because an interval going to positive infinity can never be after another interval going to positive infinity.

Parameters:

PosInfIntervalinterval The interval to check against this interval.

Example

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

pure nothrow boolisAfter(scope const NegInfInterval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Parameters:

NegInfInterval!TPinterval The interval to check against this interval.

Example

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

pure boolintersects(scope const Interval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

Interval!TPinterval The interval to check for intersection with this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolintersects(scope const PosInfIntervalinterval) const;

Whether the given interval overlaps this interval.

Always returns true because two intervals going to positive infinity always overlap.

Parameters:

PosInfIntervalinterval The interval to check for intersection with this interval.

Example

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

pure nothrow boolintersects(scope const NegInfInterval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

NegInfInterval!TPinterval The interval to check for intersection with this interval.

Example

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

Interval!TPintersection(scope const Interval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

Interval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect or if the given interval is empty.

Example

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

pure nothrow PosInfIntervalintersection(scope const PosInfIntervalinterval) const;

Returns the intersection of two intervals

Parameters:

PosInfIntervalinterval The interval to intersect with this interval.

Example

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

Interval!TPintersection(scope const NegInfInterval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

NegInfInterval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect.

Example

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

pure boolisAdjacent(scope const Interval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

Interval!TPinterval The interval to check whether its adjecent to this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolisAdjacent(scope const PosInfIntervalinterval) const;

Whether the given interval is adjacent to this interval.

Always returns false because two intervals going to positive infinity can never be adjacent to one another.

Parameters:

PosInfIntervalinterval The interval to check whether its adjecent to this interval.

Example

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

pure nothrow boolisAdjacent(scope const NegInfInterval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

NegInfInterval!TPinterval The interval to check whether its adjecent to this interval.

Example

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

PosInfIntervalmerge(scope const Interval!TPinterval) const;

Returns the union of two intervals

Parameters:

Interval!TPinterval The interval to merge with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect and are not adjacent or if the given interval is empty.

NoteThere is no overload formerge which takes aNegInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure nothrow PosInfIntervalmerge(scope const PosInfIntervalinterval) const;

Returns the union of two intervals

Parameters:

PosInfIntervalinterval The interval to merge with this interval.

NoteThere is no overload formerge which takes aNegInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure PosInfIntervalspan(scope const Interval!TPinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

Interval!TPinterval The interval to create a span together with this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

NoteThere is no overload forspan which takes aNegInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure nothrow PosInfIntervalspan(scope const PosInfIntervalinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

PosInfIntervalinterval The interval to create a span together with this interval.

NoteThere is no overload forspan which takes aNegInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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 voidshift(D)(Dduration) if (__traits(compiles, begin +duration));

Shifts thebegin of this interval forward or backwards in time by the given duration (a positive duration shifts the interval forward; a negative duration shifts it backward). Effectively, it doesbegin += duration.

Parameters:

Dduration The duration to shift the interval by.

Example

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

voidshift(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

Shifts thebegin of this interval forward or backwards in time by the given number of years and/or months (a positive number of years and months shifts the interval forward; a negative number shifts it backward). It adds the years the given years and months tobegin. It effectively callsadd!"years"() and thenadd!"months"() onbegin with the given number of years and months.

Parameters:

T`years`	The number of years to shift the interval by.
T`months`	The number of months to shift the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onbegin, causing its month to increment.

Throws:

std.datetime.date.DateTimeException if this interval is empty or if the resulting interval would be invalid.

Example

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 voidexpand(D)(Dduration) if (__traits(compiles, begin +duration));

Expands the interval backwards in time. Effectively, it doesbegin -= duration.

Parameters:

Dduration The duration to expand the interval by.

Example

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

voidexpand(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

Expands the interval forwards and/or backwards in time. Effectively, it subtracts the given number of months/years frombegin.

Parameters:

T`years`	The number of years to expand the interval by.
T`months`	The number of months to expand the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onbegin, causing its month to increment.

Throws:

std.datetime.date.DateTimeException if this interval is empty or if the resulting interval would be invalid.

Example

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

PosInfIntervalRange!TPfwdRange(TP delegate(scope const TP)func, PopFirstpopFirst = PopFirst.no) const;

Returns a range which iterates forward over the interval, starting atbegin, usingfunc to generate each successive time point.

Iffunc ever generates a time point less than or equal to the currentfront of the range, then astd.datetime.date.DateTimeException will be thrown.

There are helper functions in this module which generate common delegates to pass tofwdRange. Their documentation starts with "Range-generating function," to make them easily searchable.

Parameters:

TP delegate(scope const TP)`func`	The function used to generate the time points of the range over the interval.
PopFirst`popFirst`	WhetherpopFront should be called on the range before returning it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Of course, none of the functions in this module have this problem, so it's only relevant for custom delegates.

Example

auto interval = PosInfInterval!Date(Date(2010, 9, 1));autofunc =delegate (scopeconst Date date)//For iterating over even-numbered days.            {if ((date.day & 1) == 0)return date + dur!"days"(2);return date + dur!"days"(1);            };auto range = interval.fwdRange(func);//An odd day. Using PopFirst.yes would have made this 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);

nothrow stringtoString() const;

Converts this interval to a string.

structNegInfInterval(TP);

Represents an interval of time which has negative infinity as its starting point.

Any ranges which iterate over aNegInfInterval are infinite. So, the main purpose of usingNegInfInterval is to create an infinite range which starts at negative infinity and goes to a fixed end point. Iterate over it in reverse.

pure nothrow this(scope const TPend);

Parameters:

TPend The time point which ends the interval.

Example

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

pure nothrow ref NegInfIntervalopAssign(ref const NegInfIntervalrhs);

Parameters:

NegInfIntervalrhs TheNegInfInterval to assign to this one.

pure nothrow ref NegInfIntervalopAssign(NegInfIntervalrhs);

Parameters:

NegInfIntervalrhs TheNegInfInterval to assign to this one.

pure nothrow @property TPend() const;

The end point of the interval. It is excluded from the interval.

Example

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

pure nothrow @property voidend(TPtimePoint);

The end point of the interval. It is excluded from the interval.

Parameters:

TPtimePoint The time point to set end to.

enum boolempty;

Whether the interval's length is 0. Always returns false.

Example

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

pure nothrow boolcontains(TPtimePoint) const;

Whether the given time point is within this interval.

Parameters:

TPtimePoint The time point to check for inclusion in this interval.

Example

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

pure boolcontains(scope const Interval!TPinterval) const;

Whether the given interval is completely within this interval.

Parameters:

Interval!TPinterval The interval to check for inclusion in this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolcontains(scope const PosInfInterval!TPinterval) const;

Whether the given interval is completely within this interval.

Always returns false because an interval beginning at negative infinity can never contain an interval going to positive infinity.

Parameters:

PosInfInterval!TPinterval The interval to check for inclusion in this interval.

Example

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

pure nothrow boolcontains(scope const NegInfIntervalinterval) const;

Whether the given interval is completely within this interval.

Parameters:

NegInfIntervalinterval The interval to check for inclusion in this interval.

Example

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

pure nothrow boolisBefore(scope const TPtimePoint) const;

Whether this interval is before the given time point.

Parameters:

TPtimePoint The time point to check whether this interval is before it.

Example

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

pure boolisBefore(scope const Interval!TPinterval) const;

Whether this interval is before the given interval and does not intersect it.

Parameters:

Interval!TPinterval The interval to check for against this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty

Example

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

pure nothrow boolisBefore(scope const PosInfInterval!TPinterval) const;

Whether this interval is before the given interval and does not intersect it.

Parameters:

PosInfInterval!TPinterval The interval to check for against this interval.

Example

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

pure nothrow boolisBefore(scope const NegInfIntervalinterval) const;

Whether this interval is before the given interval and does not intersect it.

Always returns false because an interval beginning at negative infinity can never be before another interval beginning at negative infinity.

Parameters:

NegInfIntervalinterval The interval to check for against this interval.

Example

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

pure nothrow boolisAfter(scope const TPtimePoint) const;

Whether this interval is after the given time point.

Always returns false because an interval beginning at negative infinity can never be after any time point.

Parameters:

TPtimePoint The time point to check whether this interval is after it.

Example

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

pure boolisAfter(scope const Interval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Always returns false (unless the given interval is empty) because an interval beginning at negative infinity can never be after any other interval.

Parameters:

Interval!TPinterval The interval to check against this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolisAfter(scope const PosInfInterval!TPinterval) const;

Whether this interval is after the given interval and does not intersect it.

Always returns false because an interval beginning at negative infinity can never be after any other interval.

Parameters:

PosInfInterval!TPinterval The interval to check against this interval.

Example

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

pure nothrow boolisAfter(scope const NegInfIntervalinterval) const;

Whether this interval is after the given interval and does not intersect it.

Always returns false because an interval beginning at negative infinity can never be after any other interval.

Parameters:

NegInfIntervalinterval The interval to check against this interval.

Example

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

pure boolintersects(scope const Interval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

Interval!TPinterval The interval to check for intersection with this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolintersects(scope const PosInfInterval!TPinterval) const;

Whether the given interval overlaps this interval.

Parameters:

PosInfInterval!TPinterval The interval to check for intersection with this interval.

Example

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

pure nothrow boolintersects(scope const NegInfInterval!TPinterval) const;

Whether the given interval overlaps this interval.

Always returns true because two intervals beginning at negative infinity always overlap.

Parameters:

NegInfInterval!TPinterval The interval to check for intersection with this interval.

Example

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

Interval!TPintersection(scope const Interval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

Interval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect or if the given interval is empty.

Example

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

Interval!TPintersection(scope const PosInfInterval!TPinterval) const;

Returns the intersection of two intervals

Parameters:

PosInfInterval!TPinterval The interval to intersect with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect.

Example

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

nothrow NegInfIntervalintersection(scope const NegInfIntervalinterval) const;

Returns the intersection of two intervals

Parameters:

NegInfIntervalinterval The interval to intersect with this interval.

Example

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

pure boolisAdjacent(scope const Interval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

Interval!TPinterval The interval to check whether its adjecent to this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

Example

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

pure nothrow boolisAdjacent(scope const PosInfInterval!TPinterval) const;

Whether the given interval is adjacent to this interval.

Parameters:

PosInfInterval!TPinterval The interval to check whether its adjecent to this interval.

Example

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

pure nothrow boolisAdjacent(scope const NegInfIntervalinterval) const;

Whether the given interval is adjacent to this interval.

Always returns false because two intervals beginning at negative infinity can never be adjacent to one another.

Parameters:

NegInfIntervalinterval The interval to check whether its adjecent to this interval.

Example

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

NegInfIntervalmerge(scope const Interval!TPinterval) const;

Returns the union of two intervals

Parameters:

Interval!TPinterval The interval to merge with this interval.

Throws:

std.datetime.date.DateTimeException if the two intervals do not intersect and are not adjacent or if the given interval is empty.

NoteThere is no overload formerge which takes aPosInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure nothrow NegInfIntervalmerge(scope const NegInfIntervalinterval) const;

Returns the union of two intervals

Parameters:

NegInfIntervalinterval The interval to merge with this interval.

NoteThere is no overload formerge which takes aPosInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure NegInfIntervalspan(scope const Interval!TPinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

Interval!TPinterval The interval to create a span together with this interval.

Throws:

std.datetime.date.DateTimeException if the given interval is empty.

NoteThere is no overload forspan which takes aPosInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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

pure nothrow NegInfIntervalspan(scope const NegInfIntervalinterval) const;

Returns an interval that covers from the earliest time point of two intervals up to (but not including) the latest time point of two intervals.

Parameters:

NegInfIntervalinterval The interval to create a span together with this interval.

NoteThere is no overload forspan which takes aPosInfInterval, because an interval going from negative infinity to positive infinity is not possible.

Example

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 voidshift(D)(Dduration) if (__traits(compiles, end +duration));

Shifts theend of this interval forward or backwards in time by the given duration (a positive duration shifts the interval forward; a negative duration shifts it backward). Effectively, it doesend += duration.

Parameters:

Dduration The duration to shift the interval by.

Example

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

voidshift(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

Shifts theend of this interval forward or backwards in time by the given number of years and/or months (a positive number of years and months shifts the interval forward; a negative number shifts it backward). It adds the years the given years and months to end. It effectively callsadd!"years"() and thenadd!"months"() on end with the given number of years and months.

Parameters:

T`years`	The number of years to shift the interval by.
T`months`	The number of months to shift the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onend, causing its month to increment.

Throws:

std.datetime.date.DateTimeException if empty is true or if the resulting interval would be invalid.

Example

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 voidexpand(D)(Dduration) if (__traits(compiles, end +duration));

Expands the interval forwards in time. Effectively, it doesend += duration.

Parameters:

Dduration The duration to expand the interval by.

Example

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

voidexpand(T)(Tyears, Tmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes) if (isIntegral!T);

Expands the interval forwards and/or backwards in time. Effectively, it adds the given number of months/years to end.

Parameters:

T`years`	The number of years to expand the interval by.
T`months`	The number of months to expand the interval by.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onend, causing their month to increment.

Throws:

std.datetime.date.DateTimeException if empty is true or if the resulting interval would be invalid.

Example

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

NegInfIntervalRange!TPbwdRange(TP delegate(scope const TP)func, PopFirstpopFirst = PopFirst.no) const;

Returns a range which iterates backwards over the interval, starting atend, usingfunc to generate each successive time point.

Iffunc ever generates a time point greater than or equal to the currentfront of the range, then astd.datetime.date.DateTimeException will be thrown.

There are helper functions in this module which generate common delegates to pass tobwdRange. Their documentation starts with "Range-generating function," to make them easily searchable.

Parameters:

TP delegate(scope const TP)`func`	The function used to generate the time points of the range over the interval.
PopFirst`popFirst`	WhetherpopFront should be called on the range before returning it.

Throws:

std.datetime.date.DateTimeException if this interval is empty.

Iffunc retains state which changes as it is called, then some algorithms will not work correctly, because the range'ssave will have failed to have really saved the range's state. To avoid such bugs, don't pass a delegate which is not logically pure tofwdRange. Iffunc is given the same time point with two different calls, it must return the same result both times.

Of course, none of the functions in this module have this problem, so it's only relevant for custom delegates.

Example

auto interval = NegInfInterval!Date(Date(2010, 9, 9));autofunc =delegate (scopeconst Date date)//For iterating over even-numbered days.            {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));//An odd day. Using PopFirst.yes would have made this 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);

nothrow stringtoString() const;

Converts this interval to a string.

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

Range-generating function.

Returns a delegate which returns the next time point with the givenDayOfWeek in a range.

Using this delegate allows iteration over successive time points which are all the same day of the week. e.g. passingDayOfWeek.mon toeveryDayOfWeek would result in a delegate which could be used to iterate over all of the Mondays in a range.

Parameters:

dir	The direction to iterate in. If passing the return value tofwdRange, useDirection.fwd. If passing it tobwdRange, useDirection.bwd.
DayOfWeek`dayOfWeek`	The week that each time point in the range will be.

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);// A Thursday. Using PopFirst.yes would have made this 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)(intmonth) if (isTimePoint!TP && (dir == Direction.fwd || dir == Direction.bwd) && __traits(hasMember, TP, "month") && !__traits(isStaticFunction, TP.month) && is(typeof(TP.month) == Month));

Range-generating function.

Returns a delegate which returns the next time point with the given month which would be reached by adding months to the given time point.

So, using this delegate allows iteration over successive time points which are in the same month but different years. For example, iterate over each successive December 25th in an interval by starting with a date which had the 25th as its day and passedMonth.dec toeveryMonth to create the delegate.

Since it wouldn't really make sense to be iterating over a specific month and end up with some of the time points in the succeeding month or two years after the previous time point,AllowDayOverflow.no is always used when calculating the next time point.

Parameters:

dir	The direction to iterate in. If passing the return value tofwdRange, useDirection.fwd. If passing it tobwdRange, useDirection.bwd.
int`month`	The month that each time point in the range will be in (January is 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);// Using PopFirst.yes would have made this 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)(Dduration) if (isTimePoint!TP && __traits(compiles, TP.init +duration) && (dir == Direction.fwd || dir == Direction.bwd));

Range-generating function.

Returns a delegate which returns the next time point which is the given duration later.

Using this delegate allows iteration over successive time points which are apart by the given duration e.g. passingdur!"days"(3) toeveryDuration would result in a delegate which could be used to iterate over a range of days which are each 3 days apart.

Parameters:

dir	The direction to iterate in. If passing the return value tofwdRange, useDirection.fwd. If passing it tobwdRange, useDirection.bwd.
D`duration`	The duration which separates each successive time point in the range.

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);// Using PopFirst.yes would have made this 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)(intyears, intmonths = 0, AllowDayOverflowallowOverflow = AllowDayOverflow.yes, Dduration = 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));

Range-generating function.

Returns a delegate which returns the next time point which is the given number of years, month, and duration later.

The difference between this version ofeveryDuration and the version which just takes acore.time.Duration is that this one also takes the number of years and months (along with anAllowDayOverflow to indicate whether adding years and months should allow the days to overflow).

Note that if iterating forward,add!"years"() is called on the given time point, thenadd!"months"(), and finally the duration is added to it. However, if iterating backwards, the duration is added first, thenadd!"months"() is called, and finallyadd!"years"() is called. That way, going backwards generates close to the same time points that iterating forward does, but since adding years and months is not entirely reversible (due to possible day overflow, regardless of whetherAllowDayOverflow.yes orAllowDayOverflow.no is used), it can't be guaranteed that iterating backwards will give the same time points as iterating forward would have (even assuming that the end of the range is a time point which would be returned by the delegate when iterating forward frombegin).

Parameters:

dir	The direction to iterate in. If passing the return value tofwdRange, useDirection.fwd. If passing it tobwdRange, useDirection.bwd.
int`years`	The number of years to add to the time point passed to the delegate.
int`months`	The number of months to add to the time point passed to the delegate.
AllowDayOverflow`allowOverflow`	Whether the days should be allowed to overflow onbegin andend, causing their month to increment.
D`duration`	The duration to add to the time point passed to the delegate.

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);// Using PopFirst.yes would have made this 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);

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

A range over anInterval.

IntervalRange is only ever constructed byInterval. However, when it is constructed, it is given a function,func, which is used to generate the time points which are iterated over.func takes a time point and returns a time point of the same type. For instance, to iterate over all of the days in the intervalInterval!Date, pass a function toInterval'sfwdRange where that function took astd.datetime.date.Date and returned astd.datetime.date.Date which was one day later. That function would then be used byIntervalRange'spopFront to iterate over thestd.datetime.date.Dates in the interval.

Ifdir == Direction.fwd, then a range iterates forward in time, whereas ifdir == Direction.bwd, then it iterates backwards in time. So, ifdir == Direction.fwd thenfront == interval.begin, whereas ifdir == Direction.bwd thenfront == interval.end.func must generate a time point going in the proper direction of iteration, or astd.datetime.date.DateTimeException will be thrown. So, to iterate forward in time, the time point thatfunc generates must be later in time than the one passed to it. If it's either identical or earlier in time, then astd.datetime.date.DateTimeException will be thrown. To iterate backwards, then the generated time point must be before the time point which was passed in.

If the generated time point is ever passed the edge of the range in the proper direction, then the edge of that range will be used instead. So, if iterating forward, and the generated time point is past the interval'send, thenfront becomesend. If iterating backwards, and the generated time point is beforebegin, thenfront becomesbegin. In either case, the range would then be empty.

Also note that while normally thebegin of an interval is included in it and itsend is excluded from it, ifdir == Direction.bwd, thenbegin is treated as excluded andend is treated as included. This allows for the same behavior in both directions. This works because none ofInterval's functions which care about whetherbegin orend is included or excluded are ever called byIntervalRange.interval returns a normal interval, regardless of whetherdir == Direction.fwd or ifdir == Direction.bwd, so anyInterval functions which are called on it which care about whetherbegin orend are included or excluded will treatbegin as included andend as excluded.

pure nothrow ref IntervalRangeopAssign(ref IntervalRangerhs); pure nothrow ref IntervalRangeopAssign(IntervalRangerhs);

Parameters:

IntervalRangerhs TheIntervalRange to assign to this one.

pure nothrow @property boolempty() const;

Whether thisIntervalRange is empty.

pure @property TPfront() const;

The first time point in the range.

Throws:

std.datetime.date.DateTimeException if the range is empty.

voidpopFront();

Popsfront from the range, usingfunc to generate the next time point in the range. If the generated time point is beyond the edge of the range, thenfront is set to that edge, and the range is then empty. So, if iterating forwards, and the generated time point is greater than the interval'send, thenfront is set toend. If iterating backwards, and the generated time point is less than the interval'sbegin, thenfront is set tobegin.

Throws:

std.datetime.date.DateTimeException if the range is empty or if the generated time point is in the wrong direction (i.e. if iterating forward and the generated time point is beforefront, or if iterating backwards and the generated time point is afterfront).

pure nothrow @property IntervalRangesave();

Returns a copy ofthis.

pure nothrow @property Interval!TPinterval() const;

The interval that thisIntervalRange currently covers.

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

The function used to generate the next time point in the range.

pure nothrow @property Directiondirection() const;

TheDirection that this range iterates in.

structPosInfIntervalRange(TP) if (isTimePoint!TP);

A range over aPosInfInterval. It is an infinite range.

PosInfIntervalRange is only ever constructed byPosInfInterval. However, when it is constructed, it is given a function,func, which is used to generate the time points which are iterated over.func takes a time point and returns a time point of the same type. For instance, to iterate over all of the days in the intervalPosInfInterval!Date, pass a function toPosInfInterval'sfwdRange where that function took astd.datetime.date.Date and returned astd.datetime.date.Date which was one day later. That function would then be used byPosInfIntervalRange'spopFront to iterate over thestd.datetime.date.Dates in the interval - though obviously, since the range is infinite, use a function such asstd.range.take with it rather than iterating overall of the dates.

As the interval goes to positive infinity, the range is always iterated over forwards, never backwards.func must generate a time point going in the proper direction of iteration, or astd.datetime.date.DateTimeException will be thrown. So, the time points thatfunc generates must be later in time than the one passed to it. If it's either identical or earlier in time, then astd.datetime.date.DateTimeException will be thrown.

pure nothrow ref PosInfIntervalRangeopAssign(ref PosInfIntervalRangerhs); pure nothrow ref PosInfIntervalRangeopAssign(PosInfIntervalRangerhs);

Parameters:

PosInfIntervalRangerhs ThePosInfIntervalRange to assign to this one.

enum boolempty;

This is an infinite range, so it is never empty.

pure nothrow @property TPfront() const;

The first time point in the range.

voidpopFront();

Popsfront from the range, usingfunc to generate the next time point in the range.

Throws:

std.datetime.date.DateTimeException if the generated time point is less thanfront.

pure nothrow @property PosInfIntervalRangesave();

Returns a copy ofthis.

pure nothrow @property PosInfInterval!TPinterval() const;

The interval that this range currently covers.

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

The function used to generate the next time point in the range.

structNegInfIntervalRange(TP) if (isTimePoint!TP);

A range over aNegInfInterval. It is an infinite range.

NegInfIntervalRange is only ever constructed byNegInfInterval. However, when it is constructed, it is given a function,func, which is used to generate the time points which are iterated over.func takes a time point and returns a time point of the same type. For instance, to iterate over all of the days in the intervalNegInfInterval!Date, pass a function toNegInfInterval'sbwdRange where that function took astd.datetime.date.Date and returned astd.datetime.date.Date which was one day earlier. That function would then be used byNegInfIntervalRange'spopFront to iterate over thestd.datetime.date.Dates in the interval - though obviously, since the range is infinite, use a function such asstd.range.take with it rather than iterating overall of the dates.

As the interval goes to negative infinity, the range is always iterated over backwards, never forwards.func must generate a time point going in the proper direction of iteration, or astd.datetime.date.DateTimeException will be thrown. So, the time points thatfunc generates must be earlier in time than the one passed to it. If it's either identical or later in time, then astd.datetime.date.DateTimeException will be thrown.

Also note that while normally theend of an interval is excluded from it,NegInfIntervalRange treats it as if it were included. This allows for the same behavior as withPosInfIntervalRange. This works because none ofNegInfInterval's functions which care about whetherend is included or excluded are ever called byNegInfIntervalRange.interval returns a normal interval, so anyNegInfInterval functions which are called on it which care about whetherend is included or excluded will treatend as excluded.

pure nothrow ref NegInfIntervalRangeopAssign(ref NegInfIntervalRangerhs); pure nothrow ref NegInfIntervalRangeopAssign(NegInfIntervalRangerhs);

Parameters:

NegInfIntervalRangerhs TheNegInfIntervalRange to assign to this one.

enum boolempty;

This is an infinite range, so it is never empty.

pure nothrow @property TPfront() const;

The first time point in the range.

voidpopFront();

Popsfront from the range, usingfunc to generate the next time point in the range.

Throws:

std.datetime.date.DateTimeException if the generated time point is greater thanfront.

pure nothrow @property NegInfIntervalRangesave();

Returns a copy ofthis.

pure nothrow @property NegInfInterval!TPinterval() const;

The interval that this range currently covers.

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

The function used to generate the next time point in the range.

Movatterモバイル変換

Library Reference

std.datetime.interval