de.ipcon.tools.date

Interface TimespanI

All Known Subinterfaces:

IdentifiableTimespanI, SettableTimespanI, StartableAndStoppableTimespanI

All Known Implementing Classes:

DateContainer, UnstrictDateContainer

public interface TimespanI

Defines a temporal validity interval with optional inclusive boundaries.

Boundary & Infinity Semantics

• getDateStart() = null: Unbounded in the past (-infinity).
• getDateEnd() = null: Unbounded in the future (+infinity).
• Both boundaries null: Interval is completely unbounded (isAlwaysValid()).
• Defined boundaries form an inclusive interval: [startDate, endDate].

Resolution Tiers

Methods operate at one of two distinct precision tiers:

• Calendar day (Default): Ignores time-of-day components and compares whole dates. Applies to isValid(), isValidOn(Date), and isPartiallyValidDuringDays(TimespanI).
• Exact moment: Evaluates timestamps down to the millisecond. Applies to isValidAtMoment(Date) and isPartiallyValidAtAnyMomentDuring(TimespanI).

Functional Capabilities

• Point-in-Time Validity: Check whether an instant or day falls within the interval (isValid(), isValidOn(Date), isValidAtMoment(Date)) or relative to it (isValidAtOrBefore(Date), isValidAtOrAfter(Date)).
• Intersection & Overlap: Test whether intervals intersect, with optional same-day adjacency handling (overlapsWith(TimespanI, boolean), isPartiallyValidDuringDays(TimespanI)).
• Containment: Test whether this interval is completely enclosed within another interval (isCompletelyValidDuring(TimespanI)).
• Relative Positioning: Compare boundary order between two intervals (startsBeforeOrOnEndOf(TimespanI, boolean), endsAfterOrOnStartOf(TimespanI, boolean)).
• Metrics & Span: Count calendar days covered by this interval (numberOfDays()) or shared with another (overlappingDaysWith(TimespanI)).
• Integrity & Validation: Assert chronological ordering (checkConsistentDates()) and enforce closed boundaries (checkIsClosedTimespanWithConsistentDates()).

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	$0
static java.lang.String	L10N_KEY_ERR_INCONSISTENT_DATES
static java.lang.String	L10N_KEY_ERR_INDET_NUMBER_OVERLAPPING
static java.lang.String	L10N_KEY_ERR_UNWANTED_OPEN_TIMESPAN

Method Summary

Modifier and Type	Method and Description
default void	checkConsistentDates() Validates that this instance’s start date chronologically precedes or equals its end date.
static void	checkConsistentDates(java.util.Date from, java.util.Date till) Validates that the start date chronologically precedes or equals the end date.
static void	checkConsistentDates(java.util.Date from, java.util.Date till, boolean signalIllegalState) Validates that the start date chronologically precedes or equals the end date, throwing a configurable runtime exception if the interval is inverted.
default boolean	checkIsClosedTimespanWithConsistentDates() Checks whether this timespan is closed (both start and end dates are defined) and has consistent date boundaries.
default boolean	checkIsClosedTimespanWithConsistentDates(boolean doThrowIfOpen) Checks whether this timespan is closed (both start and end dates are defined) and has consistent date boundaries, with configurable enforcement for open intervals.
default boolean	coversAtMostOneMonth() Checks if this interval spans at most one calendar month.
default boolean	endsAfterOrOnStartOf(TimespanI otherTS) Checks if this interval’s end boundary is chronologically after the start boundary of otherTS.
default boolean	endsAfterOrOnStartOf(TimespanI otherTS, boolean sameDayCounts) Checks if this interval’s end boundary is chronologically after or on the start boundary of otherTS.
default boolean	equalDates(TimespanI otherTS) Checks whether this interval defines identical start and end boundaries as otherTS.
static boolean	equalDates(TimespanI oneTS, TimespanI otherTS) Null-safe comparison whether two intervals define identical start and end boundaries.
java.util.Date	getDateEnd() Returns the end boundary date of this interval.
java.util.Date	getDateStart() Returns the start boundary date of this interval.
default boolean	hasUndefinedTimespan() Checks if both boundary dates of this interval are undefined (null).
default boolean	isAlwaysValid() Checks if this interval is completely unbounded.
default boolean	isCompletelyValidDuring(java.util.Date from, java.util.Date upto) Checks if this interval is completely enclosed within the date range [from, upto].
default boolean	isCompletelyValidDuring(TimespanI during) Checks if this interval is completely enclosed within the specified interval.
default boolean	isPartiallyValidAtAnyMomentDuring(java.util.Date from, java.util.Date upto) Checks if this interval is valid at any exact millisecond moment between from and upto.
default boolean	isPartiallyValidAtAnyMomentDuring(TimespanI during) Checks if this interval is valid at any exact millisecond moment during the passed interval.
default boolean	isPartiallyValidDuring(java.util.Date from, java.util.Date upto) Deprecated. Prefer isPartiallyValidDuringDays(Date, Date).
default boolean	isPartiallyValidDuring(java.util.Date from, java.util.Date upto, boolean ignoreTime) Deprecated. Prefer isPartiallyValidDuringDays(Date, Date) for calendar-day comparison or isPartiallyValidAtAnyMomentDuring(Date, Date) for millisecond precision.
default boolean	isPartiallyValidDuring(TimespanI during) Deprecated. Prefer isPartiallyValidDuringDays(TimespanI) for calendar-day comparison
default boolean	isPartiallyValidDuring(TimespanI during, boolean ignoreTime) Deprecated. Prefer isPartiallyValidDuringDays(TimespanI) for calendar-day comparison or isPartiallyValidAtAnyMomentDuring(TimespanI) for millisecond precision.
default boolean	isPartiallyValidDuringDays(java.util.Date from, java.util.Date upto) Checks if this interval overlaps with the date range defined by [from, upto] on any calendar day.
default boolean	isPartiallyValidDuringDays(TimespanI during) Checks if this interval overlaps with the passed interval on any calendar day.
default boolean	isValid() Checks if this interval is valid today at calendar-day resolution.
default boolean	isValidAt(java.util.Date d) Deprecated. Prefer isValidOn(Date).
default boolean	isValidAt(java.util.Date d, boolean ignoreTime) Deprecated. Prefer isValidOn(Date) for day comparison or isValidAtMoment(Date) for instant comparison.
default boolean	isValidAtMoment(java.util.Date d) Checks if this interval is valid at the exact millisecond instant specified by d.
default boolean	isValidAtOrAfter(java.util.Date d) Checks if this interval is valid on or after the specified date.
default boolean	isValidAtOrBefore(java.util.Date d) Checks if this interval is valid on or before the specified date.
default boolean	isValidFromStartOfTime() Checks if this interval is valid at the start of time.
default boolean	isValidOn(java.util.Date d) Checks if this interval is valid on the given calendar day.
default boolean	isValidUntilEndOfTime() Checks if this interval has no end boundary.
default int	numberOfDays() Returns the number of days this TimespanI covers or -1 if no number of days can be determined because at least one end is open.
default int	overlappingDaysWith(TimespanI otherTS) Returns the number of days this TimespanI does overlap with the passed TimespanI.
static boolean	overlaps(TimespanI oneTS, TimespanI otherTS, boolean sameDayOverlaps) Canonical static check determining whether two timespans overlap, with configurable handling for adjacent boundaries on the same calendar day.
default boolean	overlapsWith(TimespanI other) Checks if this timespan overlaps with the specified timespan.
default boolean	overlapsWith(TimespanI other, boolean sameDayOverlaps) Checks if this timespan overlaps with the specified timespan, with configurable handling for adjacent boundaries on the same calendar day.
default boolean	startsBeforeOrOnEndOf(TimespanI otherTS) Checks if this interval’s start boundary is chronologically before the end boundary of otherTS.
default boolean	startsBeforeOrOnEndOf(TimespanI otherTS, boolean sameDayCounts) Checks if this interval’s start boundary is chronologically before or on the end boundary of otherTS.

Field Detail

$0

static final java.lang.String $0

See Also:

Constant Field Values

L10N_KEY_ERR_INCONSISTENT_DATES

static final java.lang.String L10N_KEY_ERR_INCONSISTENT_DATES

See Also:

Constant Field Values

L10N_KEY_ERR_INDET_NUMBER_OVERLAPPING

static final java.lang.String L10N_KEY_ERR_INDET_NUMBER_OVERLAPPING

See Also:

Constant Field Values

L10N_KEY_ERR_UNWANTED_OPEN_TIMESPAN

static final java.lang.String L10N_KEY_ERR_UNWANTED_OPEN_TIMESPAN

See Also:

Constant Field Values

Method Detail

checkConsistentDates

static void checkConsistentDates(java.util.Date from,
                                 java.util.Date till)

Validates that the start date chronologically precedes or equals the end date.

If from is strictly after till, an IllegalArgumentException is thrown. Unbounded boundaries (null) are considered consistent. Calling this is equivalent to checkConsistentDates(from, till, false).

Parameters:

from - the starting boundary date, or null if unbounded in the past

till - the ending boundary date, or null if unbounded in the future

Throws:

java.lang.IllegalArgumentException - if from is chronologically after till

checkConsistentDates

static void checkConsistentDates(java.util.Date from,
                                 java.util.Date till,
                                 boolean signalIllegalState)

Validates that the start date chronologically precedes or equals the end date, throwing a configurable runtime exception if the interval is inverted.

An interval is considered consistent if:

• either boundary is null (unbounded interval), or
• from is chronologically before or identical to till.

The signalIllegalState parameter controls the exception type raised upon violation:

• Use false when validating incoming method arguments (raises IllegalArgumentException).
• Use true when asserting the integrity of an existing instance state (raises IllegalStateException).

Parameters:

from - the starting boundary date, or null if unbounded in the past

till - the ending boundary date, or null if unbounded in the future

signalIllegalState - true to throw an IllegalStateException; false to throw an IllegalArgumentException

Throws:

java.lang.IllegalArgumentException - if from is after till and signalIllegalState is false

java.lang.IllegalStateException - if from is after till and signalIllegalState is true

getDateStart

java.util.Date getDateStart()

Returns the start boundary date of this interval.

Returns:

the boundary start date, or null if valid from the start of time

getDateEnd

java.util.Date getDateEnd()

Returns the end boundary date of this interval.

Note: In day-level comparisons (such as isValid() and isValidOn(Date)), this date is treated as an inclusive calendar day (valid through 23:59:59.999 of that day). In millisecond-level comparisons (isValidAtMoment(Date)), it is evaluated as an exact instant.

Returns:

the boundary end date, or null if open-ended

checkConsistentDates

default void checkConsistentDates()

Validates that this instance’s start date chronologically precedes or equals its end date.

An interval is considered consistent if either boundary is null (unbounded interval) or getDateStart() is chronologically before or identical to getDateEnd().

Throws:

java.lang.IllegalStateException - if getDateStart() is chronologically after getDateEnd()

checkIsClosedTimespanWithConsistentDates

default boolean checkIsClosedTimespanWithConsistentDates()

Checks whether this timespan is closed (both start and end dates are defined) and has consistent date boundaries.

An interval is closed if both getDateStart() and getDateEnd() are non-null. If either boundary is null, this method returns false without raising an exception. Inconsistent dates (start after end) will always raise an IllegalArgumentException. Calling this is equivalent to checkIsClosedTimespanWithConsistentDates(false).

Returns:

true if this timespan is closed and validly ordered; false if it is open-ended at either boundary

Throws:

java.lang.IllegalArgumentException - if getDateStart() is chronologically after getDateEnd()

checkIsClosedTimespanWithConsistentDates

default boolean checkIsClosedTimespanWithConsistentDates(boolean doThrowIfOpen)

Checks whether this timespan is closed (both start and end dates are defined) and has consistent date boundaries, with configurable enforcement for open intervals.

An interval is considered closed and consistent if:

• both getDateStart() and getDateEnd() are non-null, and
• getDateStart() chronologically precedes or equals getDateEnd().

Inconsistent dates (start strictly after end) are an illegal state and will always raise an IllegalArgumentException. The doThrowIfOpen parameter dictates how open-ended boundaries (at least one null) are handled:

• If false: Open boundaries are accepted as a regular non-match and return false.
• If true: A closed interval is strictly enforced, raising an IllegalArgumentException if either boundary is missing.

Parameters:

doThrowIfOpen - true to throw an IllegalArgumentException if the timespan is open at either boundary; false to return false instead

Returns:

true if this timespan is closed and consistent; false if open-ended at either boundary and doThrowIfOpen is false

Throws:

java.lang.IllegalArgumentException - if getDateStart() is chronologically after getDateEnd(), or if the timespan is open-ended and doThrowIfOpen is true

coversAtMostOneMonth

default boolean coversAtMostOneMonth()

Checks if this interval spans at most one calendar month.

Open-ended intervals (where either boundary is null) cannot be evaluated against a fixed duration and return false.

Returns:

true if the closed interval spans at most one month; false if open-ended

Throws:

java.lang.IllegalStateException - if getDateStart() is chronologically after getDateEnd()

isValid

default boolean isValid()

Checks if this interval is valid today at calendar-day resolution.

Equivalent to calling isValidOn(Date()).

Returns:

true if today falls within [getDateStart(), getDateEnd()] as whole calendar days

isValidOn

default boolean isValidOn(java.util.Date d)

Checks if this interval is valid on the given calendar day.

This evaluates against whole calendar days, ignoring hour/minute/second components. Both start and end dates are treated as inclusive.

Parameters:

d - the calendar date to check

Returns:

true if d falls within [getDateStart(), getDateEnd()]

isValidAtMoment

default boolean isValidAtMoment(java.util.Date d)

Checks if this interval is valid at the exact millisecond instant specified by d.

Parameters:

d - the exact timestamp to check

Returns:

true if d is on or after getDateStart() and on or before getDateEnd()

isValidAt

@Deprecated
default boolean isValidAt(java.util.Date d)

Deprecated. Prefer isValidOn(Date).

Checks if this interval is valid on the given calendar day.

Parameters:

d - the calendar date to check

Returns:

true if d falls within [getDateStart(), getDateEnd()]

isValidAt

@Deprecated
default boolean isValidAt(java.util.Date d,
                                      boolean ignoreTime)

Deprecated. Prefer isValidOn(Date) for day comparison or isValidAtMoment(Date) for instant comparison.

Checks validity with explicit resolution control.

Parameters:

d - the date to check

ignoreTime - true to evaluate by calendar day; false to evaluate by exact millisecond

Returns:

true if valid according to selected resolution

isPartiallyValidDuringDays

default boolean isPartiallyValidDuringDays(TimespanI during)

Checks if this interval overlaps with the passed interval on any calendar day.

Evaluates boundaries at inclusive calendar-day resolution (ignoring time components).

Parameters:

during - the interval to check against, or null for an unbounded interval

Returns:

true if both intervals share at least one calendar day

isPartiallyValidDuringDays

default boolean isPartiallyValidDuringDays(java.util.Date from,
                                           java.util.Date upto)

Checks if this interval overlaps with the date range defined by [from, upto] on any calendar day.

Both boundaries are evaluated as inclusive calendar days.

Parameters:

from - start date (inclusive), or null if unbounded in past

upto - end date (inclusive), or null if unbounded in future

Returns:

true if both ranges share at least one calendar day

isPartiallyValidAtAnyMomentDuring

default boolean isPartiallyValidAtAnyMomentDuring(TimespanI during)

Checks if this interval is valid at any exact millisecond moment during the passed interval.

Parameters:

during - the interval to check against, or null for an unbounded interval

Returns:

true if both intervals share an exact moment in time

isPartiallyValidAtAnyMomentDuring

default boolean isPartiallyValidAtAnyMomentDuring(java.util.Date from,
                                                  java.util.Date upto)

Checks if this interval is valid at any exact millisecond moment between from and upto.

Parameters:

from - start timestamp (inclusive), or null if unbounded in past

upto - end timestamp (inclusive), or null if unbounded in future

Returns:

true if both intervals share an exact millisecond

isPartiallyValidDuring

@Deprecated
default boolean isPartiallyValidDuring(TimespanI during)

Deprecated. Prefer isPartiallyValidDuringDays(TimespanI) for calendar-day comparison

Checks if this interval overlaps with the passed interval at calendar-day resolution.

Parameters:

during - the interval to check against

Returns:

true if there is any calendar-day overlap

isPartiallyValidDuring

@Deprecated
default boolean isPartiallyValidDuring(TimespanI during,
                                                   boolean ignoreTime)

Deprecated. Prefer isPartiallyValidDuringDays(TimespanI) for calendar-day comparison or isPartiallyValidAtAnyMomentDuring(TimespanI) for millisecond precision.

Checks if this interval overlaps with the passed interval with explicit resolution control.

Parameters:

during - the interval to check against

ignoreTime - true to evaluate by calendar day; false to evaluate by exact millisecond

Returns:

true if there is an overlap according to selected resolution

isPartiallyValidDuring

@Deprecated
default boolean isPartiallyValidDuring(java.util.Date from,
                                                   java.util.Date upto)

Deprecated. Prefer isPartiallyValidDuringDays(Date, Date).

Checks if this interval overlaps with the range [from, upto] at calendar-day resolution.

Parameters:

from - start date (inclusive), or null

upto - end date (inclusive), or null

Returns:

true if both intervals overlap on any calendar day

isPartiallyValidDuring

@Deprecated
default boolean isPartiallyValidDuring(java.util.Date from,
                                                   java.util.Date upto,
                                                   boolean ignoreTime)

Deprecated. Prefer isPartiallyValidDuringDays(Date, Date) for calendar-day comparison or isPartiallyValidAtAnyMomentDuring(Date, Date) for millisecond precision.

Checks if this interval overlaps with the range [from, upto] with explicit resolution control.

Parameters:

from - start boundary, or null

upto - end boundary, or null

ignoreTime - true to evaluate by calendar day; false to evaluate by exact millisecond

Returns:

true if there is an overlap according to selected resolution

isCompletelyValidDuring

default boolean isCompletelyValidDuring(java.util.Date from,
                                        java.util.Date upto)

Checks if this interval is completely enclosed within the date range [from, upto].

Both boundaries of the enclosing range are evaluated at calendar-day resolution.

Parameters:

from - the start boundary of the enclosing range (inclusive), or null if unbounded in past

upto - the end boundary of the enclosing range (inclusive), or null if unbounded in future

Returns:

true if this interval is entirely contained within [from, upto]

isCompletelyValidDuring

default boolean isCompletelyValidDuring(TimespanI during)

Checks if this interval is completely enclosed within the specified interval.

Evaluates whether both the start and end boundaries of this interval fall within during at calendar-day resolution.

Parameters:

during - the enclosing interval to test against

Returns:

true if this interval is entirely contained within during; false if during is null or does not fully contain this interval

isAlwaysValid

default boolean isAlwaysValid()

Checks if this interval is completely unbounded.

Returns:

true if both start and end dates are null

isValidFromStartOfTime

default boolean isValidFromStartOfTime()

Checks if this interval is valid at the start of time.

Returns:

true if getDateStart() is null

isValidUntilEndOfTime

default boolean isValidUntilEndOfTime()

Checks if this interval has no end boundary.

Returns:

true if getDateEnd() is null

isValidAtOrBefore

default boolean isValidAtOrBefore(java.util.Date d)

Checks if this interval is valid on or before the specified date.

Evaluates whether getDateStart() chronologically precedes or matches d. If this interval is unbounded in the past (isValidFromStartOfTime()), this method always returns true.

Parameters:

d - the reference timestamp to test against

Returns:

true if this interval starts on or before d

isValidAtOrAfter

default boolean isValidAtOrAfter(java.util.Date d)

Checks if this interval is valid on or after the specified date.

Evaluates whether getDateEnd() chronologically succeeds or matches d. If this interval is open-ended into the future (isValidUntilEndOfTime()), this method always returns true.

Parameters:

d - the reference timestamp to test against

Returns:

true if this interval ends on or after d

hasUndefinedTimespan

default boolean hasUndefinedTimespan()

Checks if both boundary dates of this interval are undefined (null).

Semantic alias for isAlwaysValid().

Returns:

true if both start and end dates are null

overlapsWith

default boolean overlapsWith(TimespanI other)

Checks if this timespan overlaps with the specified timespan.

Touching or adjacent timespans (where one ends on the same day the other begins) are not considered overlapping. Calling this is equivalent to overlapsWith(other, 0).

Parameters:

other - the timespan to check for overlap

Returns:

true if this timespan overlaps with other; false otherwise or if other is null

overlapsWith

default boolean overlapsWith(TimespanI other,
                             boolean sameDayOverlaps)

Checks if this timespan overlaps with the specified timespan, with configurable handling for adjacent boundaries on the same calendar day.

Two timespans overlap when both intervals share a common period in time. The sameDayOverlaps parameter controls boundary evaluation when one interval ends on the exact day that the other interval begins:

• If true: Adjacent intervals (e.g. interval A ends on the same calendar day interval B begins) are counted as overlapping.
• If false: Adjacent intervals are treated as consecutive/disjoint and do not count as overlapping.

Parameters:

other - the timespan to check for overlap with this instance, may be null

sameDayOverlaps - true to count boundary touching on the same day as an overlap; false to treat adjacent boundaries as non-overlapping

Returns:

true if this timespan overlaps with other; false otherwise or if other is null

overlaps

static boolean overlaps(TimespanI oneTS,
                        TimespanI otherTS,
                        boolean sameDayOverlaps)

Canonical static check determining whether two timespans overlap, with configurable handling for adjacent boundaries on the same calendar day.

This method provides a strictly symmetric relation: overlaps(a, b, s) == overlaps(b, a, s).

The sameDayOverlaps parameter controls boundary evaluation when one interval ends on the exact day that the other interval begins:

• If true: Adjacent intervals (e.g. interval A ends on the same calendar day interval B begins) are counted as overlapping.
• If false: Adjacent intervals are treated as consecutive/disjoint and do not count as overlapping.

Parameters:

oneTS - the first timespan, may be null

otherTS - the second timespan, may be null

sameDayOverlaps - true to count boundary touching on the same day as an overlap; false to treat adjacent boundaries as non-overlapping

Returns:

true if oneTS overlaps with otherTS; false if they are disjoint or if either parameter is null

overlappingDaysWith

default int overlappingDaysWith(TimespanI otherTS)

Returns the number of days this TimespanI does overlap with the passed TimespanI. If both TimespanI-s are unlimited on the same end, an IllegalArgumentException is signalled.

Parameters:

other - the timespan to count the overlapping days with this timespan for

Returns:

the number of days the timespan of this instance overlaps with the timespan of the other instance, or 0 if a null TimespanI is passed

Throws:

java.lang.IllegalArgumentException - if the passed TimespanI and this instance are both unlimited and thus infinity would be the result

java.lang.IllegalStateException - if this instance or the passed TimespanI are not temporally consistent

numberOfDays

default int numberOfDays()

Returns the number of days this TimespanI covers or -1 if no number of days can be determined because at least one end is open.

Returns:

the number of days this TimespanI covers or -1 if no number of days can be determined because at least one end is open

Throws:

java.lang.IllegalStateException - if this instance is not temporally consistent

endsAfterOrOnStartOf

default boolean endsAfterOrOnStartOf(TimespanI otherTS)

Checks if this interval’s end boundary is chronologically after the start boundary of otherTS.

Adjacent boundaries on the exact same calendar day are not counted as satisfying the condition. Calling this is equivalent to endsAfterOrOnStartOf(otherTS, false).

Parameters:

otherTS - the interval to compare against

Returns:

true if this interval ends after otherTS starts; false otherwise or if otherTS is null

endsAfterOrOnStartOf

default boolean endsAfterOrOnStartOf(TimespanI otherTS,
                                     boolean sameDayCounts)

Checks if this interval’s end boundary is chronologically after or on the start boundary of otherTS.

The sameDayCounts parameter controls whether boundary touching on the same day counts as a match:

• If true: The same calendar day counts as satisfying the condition (evaluates >= on day level).
• If false: The same day does not count; this interval must end strictly after the start of otherTS (evaluates strict > via after()).

Parameters:

otherTS - the interval to compare against

sameDayCounts - true to count the same calendar day as a match; false to require strict inequality (same day does not count)

Returns:

true if the condition is satisfied; false otherwise or if otherTS is null

startsBeforeOrOnEndOf

default boolean startsBeforeOrOnEndOf(TimespanI otherTS)

Checks if this interval’s start boundary is chronologically before the end boundary of otherTS.

Adjacent boundaries on the exact same calendar day are not counted as satisfying the condition. Calling this is equivalent to startsBeforeOrOnEndOf(otherTS, false).

Parameters:

otherTS - the interval to compare against

Returns:

true if this interval starts before otherTS ends; false otherwise or if otherTS is null

startsBeforeOrOnEndOf

default boolean startsBeforeOrOnEndOf(TimespanI otherTS,
                                      boolean sameDayCounts)

Checks if this interval’s start boundary is chronologically before or on the end boundary of otherTS.

The sameDayCounts parameter controls whether boundary touching on the same day counts as a match:

• If true: The same calendar day counts as satisfying the condition (evaluates <= on day level).
• If false: The same day does not count; this interval must start strictly before the end of otherTS (evaluates strict < via before()).

Parameters:

otherTS - the interval to compare against

sameDayCounts - true to count the same calendar day as a match; false to require strict inequality (same day does not count)

Returns:

true if the condition is satisfied; false otherwise or if otherTS is null

equalDates

static boolean equalDates(TimespanI oneTS,
                          TimespanI otherTS)

Null-safe comparison whether two intervals define identical start and end boundaries.

Parameters:

oneTS - the first interval, may be null

otherTS - the second interval, may be null

Returns:

true if both intervals are null or define identical boundary dates; false otherwise

equalDates

default boolean equalDates(TimespanI otherTS)

Checks whether this interval defines identical start and end boundaries as otherTS.

Parameters:

otherTS - the interval to compare with

Returns:

true if both start dates match and both end dates match; false if dates differ or if otherTS is null