TimespanI (MyTISM API Documentation)

All Known Subinterfaces:

IdentifiableTimespanI, SettableTimespanI, StartableAndStoppableTimespanI

All Known Implementing Classes:

DateContainer, UnstrictDateContainer
```
public interface TimespanI
```

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

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default void`	`checkConsistentDates()` Checks if DateStart is not after DateEnd and throws an IllegalArgumentException otherwise.
`static void`	`checkConsistentDates(java.util.Date from, java.util.Date till)` Checks if the passed starting date is not later than the passed ending date.
`static void`	`checkConsistentDates(java.util.Date from, java.util.Date till, boolean signalIllegalState)`
`default boolean`	`checkIsClosedTimespanWithConsistentDates()` Checks whether this Timespan is closed (both starting and ending dates are defined) and whether these dates are consistent.
`default boolean`	`checkIsClosedTimespanWithConsistentDates(boolean doThrowIfOpen)`
`default boolean`	`coversAtMostOneMonth()` Returns true if this TimespanI covers at most one month.
`default boolean`	`endsAfterOrOnStartOf(TimespanI otherTS)`
`default boolean`	`endsAfterOrOnStartOf(TimespanI otherTS, boolean sameDayCounts)`
`default boolean`	`equalDates(TimespanI otherTS)`
`static boolean`	`equalDates(TimespanI oneTS, TimespanI otherTS)`
`java.util.Date`	`getDateEnd()`
`java.util.Date`	`getDateStart()`
`default boolean`	`hasUndefinedTimespan()` Returns true if the start and end date of this TimespanI are null.
`default boolean`	`isAlwaysValid()`
`default boolean`	`isCompletelyValidDuring(java.util.Date from, java.util.Date upto)`
`default boolean`	`isCompletelyValidDuring(TimespanI during)` Checks if this TimespanI is valid during the passed TimespanI.
`default boolean`	`isPartiallyValidDuring(java.util.Date from, java.util.Date upto)` Checks if this TimespanI is valid at any time between the passed dates.
`default boolean`	`isPartiallyValidDuring(java.util.Date from, java.util.Date upto, boolean ignoreTime)`
`default boolean`	`isPartiallyValidDuring(TimespanI during)` Checks if this TimespanI is valid at any time during the timespan defined by the passed TimespanI.
`default boolean`	`isPartiallyValidDuring(TimespanI during, boolean ignoreTime)`
`default boolean`	`isValid()` Checks if this TimespanI is valid at the current time.
`default boolean`	`isValidAt(java.util.Date d)` Checks if this TimespanI is valid on the passed date (and optionally at the time defined by the passed Date object).
`default boolean`	`isValidAt(java.util.Date d, boolean ignoreTime)`
`default boolean`	`isValidAtOrAfter(java.util.Date d)`
`default boolean`	`isValidAtOrBefore(java.util.Date d)`
`default boolean`	`isValidFromStartOfTime()`
`default boolean`	`isValidOn(java.util.Date d)` Checks if this TimespanI is valid on the passed date.
`default boolean`	`isValidUntilEndOfTime()`
`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.
`default boolean`	`overlapsWith(TimespanI other)`
`default boolean`	`overlapsWith(TimespanI other, boolean sameDayOverlaps)`
`default boolean`	`startsBeforeOrOnEndOf(TimespanI otherTS)`
`default boolean`	`startsBeforeOrOnEndOf(TimespanI otherTS, boolean sameDayCounts)`

- 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)
```
    Checks if the passed starting date is not later than the passed ending date. Otherwise either an IllegalArgumentException or an IllegalStateException is thrown, depending on the requested type.
    
    Parameters:
    
    from - the starting date to check
    
    till - the ending date to check
    
    signalIllegalState - a boolean determining if an IllegalStateException shall be raised instead of an IllegalArgumentException in case the check fails (defaults to false)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the check fails and signalIllegalState was passed as false (default)
    
    java.lang.IllegalStateException - if the check fails and signalIllegalState was passed as true
  - checkConsistentDates
```
static void checkConsistentDates(java.util.Date from,
                                 java.util.Date till,
                                 boolean signalIllegalState)
```
  - getDateStart
```
java.util.Date getDateStart()
```
    Returns:
    
    the moment this timespan begins or null, if it is valid since the start of time
  - getDateEnd
```
java.util.Date getDateEnd()
```
    Returns:
    
    the moment this timespan ends or null, if it is 'open end'
  - checkConsistentDates
```
default void checkConsistentDates()
```
    Checks if DateStart is not after DateEnd and throws an IllegalArgumentException otherwise.
  - checkIsClosedTimespanWithConsistentDates
```
default boolean checkIsClosedTimespanWithConsistentDates()
```
    Checks whether this Timespan is closed (both starting and ending dates are defined) and whether these dates are consistent.
    
    Parameters:
    
    doThrowIfOpen - If set to true, an IllegalArgumentException will be thrown if the Timespan is open at either end.
    
    Returns:
    
    false if this Timespan is open at either the starting or ending date, and the 'doThrowIfOpen' parameter is set to false. Returns true otherwise.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the starting and ending dates are inconsistent, which is never desirable, or if the Timespan is open at any end and 'doThrowIfOpen' is set to true.
  - checkIsClosedTimespanWithConsistentDates
```
default boolean checkIsClosedTimespanWithConsistentDates(boolean doThrowIfOpen)
```
  - coversAtMostOneMonth
```
default boolean coversAtMostOneMonth()
```
    Returns true if this TimespanI covers at most one month.
  - isValid
```
default boolean isValid()
```
    Checks if this TimespanI is valid at the current time. A TimespanI is considered "valid" at a given date, if the date is included in the interval defined by this TimespanI.
    
    Returns:
    
    true if this TimespanI is currently "valid" i.e. the current date is included in the interval defined by this TimespanI
  - isValidOn
```
default boolean isValidOn(java.util.Date d)
```
    Checks if this TimespanI is valid on the passed date. A TimespanI is considered "valid" on a given date if the passed date is included in the inclusive interval defined by this TimespanI.
    
    Parameters:
    
    d - the date for which we test for validity of the TimespanI
    
    Returns:
    
    true if this TimespanI is valid on the passed date
  - isValidAt
```
default boolean isValidAt(java.util.Date d)
```
    Checks if this TimespanI is valid on the passed date (and optionally at the time defined by the passed Date object). A TimespanI is considered "valid" on a given date (and optionally at the time), if the passed date is included in the inclusive interval defined by this TimespanI.
    
    Parameters:
    
    d - the date for which we test for validity of the TimespanI
    
    ignoreTime - a boolean determining if the time shall be ignored in the comparison, defaults to true
    
    Returns:
    
    true if this TimespanI is valid on the passed date (and optionally at the time).
  - isValidAt
```
default boolean isValidAt(java.util.Date d,
                          boolean ignoreTime)
```
  - isPartiallyValidDuring
```
default boolean isPartiallyValidDuring(TimespanI during)
```
    Checks if this TimespanI is valid at any time during the timespan defined by the passed TimespanI. It does not need to be completely included in the given TimespanI. It may start after "DateStart" and/or end before "DateEnd" of the passed TimespanI.
  - isPartiallyValidDuring
```
default boolean isPartiallyValidDuring(TimespanI during,
                                       boolean ignoreTime)
```
  - isPartiallyValidDuring
```
default boolean isPartiallyValidDuring(java.util.Date from,
                                       java.util.Date upto)
```
    Checks if this TimespanI is valid at any time between the passed dates. It does not need to be completely included in the given timespan. It may start after "from" and/or end before "upto"
  - isPartiallyValidDuring
```
default boolean isPartiallyValidDuring(java.util.Date from,
                                       java.util.Date upto,
                                       boolean ignoreTime)
```
  - isCompletelyValidDuring
```
default boolean isCompletelyValidDuring(java.util.Date from,
                                        java.util.Date upto)
```
    See Also:
    
    isCompletelyValidDuring(TimespanI)
  - isCompletelyValidDuring
```
default boolean isCompletelyValidDuring(TimespanI during)
```
    Checks if this TimespanI is valid during the passed TimespanI. A TimespanI is considered "valid" during a given TimespanI if the interval defined by this TimespanI is (at least) completely included in the given TimespanI.
    
    Parameters:
    
    during - the TimespanI for which we test this TimespanI to be valid for completely
    
    Returns:
    
    true if the interval defined by this TimespanI is (at least) completely included in the given TimespanI, false otherwise
  - isAlwaysValid
```
default boolean isAlwaysValid()
```
    Returns:
    
    true if this TimespanI is always valid, i.e. the interval represents infinity.
  - isValidFromStartOfTime
```
default boolean isValidFromStartOfTime()
```
    Returns:
    
    true if this TimespanI is valid from the start of time, i.e. the left border of the interval represents negative infinity.
  - isValidUntilEndOfTime
```
default boolean isValidUntilEndOfTime()
```
    Returns:
    
    true if this TimespanI is valid until the end of time, i.e. the right border of the interval represents positive infinity.
  - isValidAtOrBefore
```
default boolean isValidAtOrBefore(java.util.Date d)
```
    Returns:
    
    true if this timespan is valid at the given date or sometime before
  - isValidAtOrAfter
```
default boolean isValidAtOrAfter(java.util.Date d)
```
    Returns:
    
    true if this timespan is valid at the given date or sometime after
  - hasUndefinedTimespan
```
default boolean hasUndefinedTimespan()
```
    Returns true if the start and end date of this TimespanI are null.
  - overlapsWith
```
default boolean overlapsWith(TimespanI other)
```
    Parameters:
    
    other - the timespan to check for overlapping with this timespan
    
    sameDayOverlaps - whether a timespan that ends on the day the next one starts counts as overlapping
    
    Returns:
    
    true if the timespan of this instance overlaps with the timespan of the other instance, false otherwise of if null is passed. - a timespan that ends on the same instance another one starts does not count as overlapping if sameDayOverlaps is set to false FIXME!! 2021-11-11 fs, this method should be final as it already sufficiently defines time based overlapping Also, this could lead to unnecessary confusion when some classes override the method Example: Class A has overridden the method, Class B hasn't a.overlapsWith(b) -> false b.overlapsWIth(a) -> true
  - overlapsWith
```
default boolean overlapsWith(TimespanI other,
                             boolean sameDayOverlaps)
```
  - 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)
```
  - endsAfterOrOnStartOf
```
default boolean endsAfterOrOnStartOf(TimespanI otherTS,
                                     boolean sameDayCounts)
```
  - startsBeforeOrOnEndOf
```
default boolean startsBeforeOrOnEndOf(TimespanI otherTS)
```
  - startsBeforeOrOnEndOf
```
default boolean startsBeforeOrOnEndOf(TimespanI otherTS,
                                      boolean sameDayCounts)
```
  - equalDates
```
static boolean equalDates(TimespanI oneTS,
                          TimespanI otherTS)
```
  - equalDates
```
default boolean equalDates(TimespanI otherTS)
```

Interface TimespanI

Field Summary

Method Summary

Field Detail

$0

L10N_KEY_ERR_INCONSISTENT_DATES

L10N_KEY_ERR_INDET_NUMBER_OVERLAPPING

L10N_KEY_ERR_UNWANTED_OPEN_TIMESPAN

Method Detail

checkConsistentDates

checkConsistentDates

getDateStart

getDateEnd

checkConsistentDates

checkIsClosedTimespanWithConsistentDates

checkIsClosedTimespanWithConsistentDates

coversAtMostOneMonth

isValid

isValidOn

isValidAt

isValidAt

isPartiallyValidDuring

isPartiallyValidDuring

isPartiallyValidDuring

isPartiallyValidDuring

isCompletelyValidDuring

isCompletelyValidDuring

isAlwaysValid

isValidFromStartOfTime

isValidUntilEndOfTime

isValidAtOrBefore

isValidAtOrAfter

hasUndefinedTimespan

overlapsWith

overlapsWith

overlappingDaysWith

numberOfDays

endsAfterOrOnStartOf

endsAfterOrOnStartOf

startsBeforeOrOnEndOf

startsBeforeOrOnEndOf

equalDates

equalDates