TimeIntervalCollection

java.lang.Object
- agi.foundation.time.TimeIntervalCollection

All Implemented Interfaces:

IEquatable<TimeIntervalCollection>, IEquatableEpsilon<TimeIntervalCollection>, IFreezable, Iterable<TimeInterval>, Collection<TimeInterval>, List<TimeInterval>
```
public final class TimeIntervalCollection
extends Object
implements List<TimeInterval>, IEquatable<TimeIntervalCollection>, IEquatableEpsilon<TimeIntervalCollection>, IFreezable
```
A collection of time intervals. The intervals are sorted by their start date and no two intervals in the list overlap each other.

Constructor Summary

Constructors
Constructor and Description
`TimeIntervalCollection()` Initializes a new, empty interval collection.
`TimeIntervalCollection(TimeInterval interval)` Initializes a new instance from a single interval.
`TimeIntervalCollection(TimeIntervalCollection collection)` Initializes a new interval collection by copying an existing one.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(int index, TimeInterval item)` Adds a time interval to the list.
`boolean`	`add(TimeInterval item)` Adds an interval to the interval collection.
`void`	`add(TimeIntervalCollection collection)` Adds another interval collection to this interval collection.
`boolean`	`addAll(Collection<? extends TimeInterval> c)` Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation).
`boolean`	`addAll(int index, Collection<? extends TimeInterval> c)` Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
`<T> TimeIntervalCollection1<T>`	`addData(T data)` Converts this collection to a `TimeIntervalCollection1` by filling in the `Data` (`get`) property for all intervals.
`void`	`clear()` Removes all intervals from the interval collection.
`TimeIntervalCollection`	`complement(JulianDate startDate, JulianDate endDate)` Computes the complement of this time interval collection.
`boolean`	`contains(JulianDate date)` Determines if the collection contains a specified date.
`boolean`	`contains(Object item)` Determines if this collection contains all of a specified interval.
`boolean`	`containsAll(Collection<?> c)` Returns `true` if this list contains all of the elements of the specified collection.
`void`	`copyTo(TimeInterval[] array, int arrayIndex)` Copies the intervals in this collection to an array.
`boolean`	`equals(Object obj)` Indicates whether another object is exactly equal to this instance.
`static boolean`	`equals(TimeIntervalCollection left, TimeIntervalCollection right)` Returns `true` if the two instances are exactly equal.
`boolean`	`equalsEpsilon(TimeIntervalCollection other, double epsilon)` Determines if this `TimeIntervalCollection` is equal to another by comparing each of the `TimeInterval` elements in the two collections with `TimeInterval.equalsEpsilon(agi.foundation.time.TimeInterval, double)`.
`boolean`	`equalsType(TimeIntervalCollection other)` Indicates whether another instance of this type is exactly equal to this instance.
`TimeInterval`	`findIntervalContainingDate(JulianDate date)` Finds the `TimeInterval` in this collection that contains a specified date.
`void`	`freeze()` Freezes this object.
`TimeInterval`	`get(int index)` Gets the interval at the specified index.
`static TimeIntervalCollection`	`getEmpty()` Gets an empty, read-only `TimeIntervalCollection`.
`static TimeIntervalCollection`	`getInfinite()` Gets an unbounded, infinite, read-only `TimeIntervalCollection`.
`boolean`	`getIsEmpty()` Gets a value indicating whether this interval collection is empty, where emptiness is defined as the count of intervals being equal to zero.
`boolean`	`getIsFrozen()` Gets a value indicating whether this object is frozen.
`boolean`	`getIsInfinite()` Gets a value indicating whether the interval collection is infinite.
`JulianDate`	`getStart()` Gets the start date of the first interval in the collection.
`JulianDate`	`getStop()` Gets the stop date of the last interval in the collection
`int`	`hashCode()` Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.
`int`	`indexOf(JulianDate date)` Finds the index of the `TimeInterval` in this collection that contains the specified date.
`int`	`indexOf(Object item)` Finds the index of a given `TimeInterval` in the collection.
`TimeIntervalCollection`	`intersect(TimeInterval interval)` Computes the intersection of this interval collection with an interval.
`TimeIntervalCollection`	`intersect(TimeIntervalCollection collection)` Computes the intersection of this interval collection with another.
`boolean`	`isEmpty()` Returns `true` if this list contains no elements.
`Iterator<TimeInterval>`	`iterator()` Gets an enumerator for this interval list.
`int`	`lastIndexOf(Object o)` Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
`ListIterator<TimeInterval>`	`listIterator()` Returns a list iterator over the elements in this list (in proper sequence).
`ListIterator<TimeInterval>`	`listIterator(int index)` Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
`static boolean`	`notEquals(TimeIntervalCollection left, TimeIntervalCollection right)` Returns `true` if the two instances are not exactly equal.
`TimeInterval`	`remove(int index)` Removes the interval at a specified index in the collection.
`boolean`	`remove(Object item)` Removes the specified interval from this interval list, creating a hole over the specified interval.
`boolean`	`remove(TimeIntervalCollection collection)` Removes the specified intervals from this interval list, creating a hole over the specified intervals.
`boolean`	`removeAll(Collection<?> c)` Removes from this list all of its elements that are contained in the specified collection (optional operation).
`boolean`	`removeLeavingEndpoints(TimeInterval item)` Removes the specified interval from this interval list, creating a hole over the specified interval.
`boolean`	`removeLeavingEndpoints(TimeIntervalCollection collection)` Removes the specified intervals from this interval list, creating a hole over the specified intervals.
`boolean`	`retainAll(Collection<?> c)` Retains only the elements in this list that are contained in the specified collection (optional operation).
`TimeInterval`	`set(int index, TimeInterval value)` Sets the interval at the specified index.
`int`	`size()` Gets the number of intervals in this interval collection.
`List<TimeInterval>`	`subList(int fromIndex, int toIndex)` Returns a view of the portion of this list between the specified `fromIndex`, inclusive, and `toIndex`, exclusive.
`Object[]`	`toArray()` Returns an array containing all of the elements in this list in proper sequence (from first to last element).
`<T> T[]`	`toArray(T[] a)` Returns an array containing all of the elements in this list in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.
`Duration`	`toDuration()` Returns a `Duration` representing the span of time represented by the sum of the individual time intervals in the collection.
`String`	`toString()` Returns a string representation of the object.
`TimeIntervalCollection`	`toTimeStandard(TimeStandard timeStandard)` Converts all times in this time interval collection to be the specified time standard.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List
replaceAll, sort, spliterator

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - TimeIntervalCollection
```
public TimeIntervalCollection()
```
    Initializes a new, empty interval collection.
  - TimeIntervalCollection
```
public TimeIntervalCollection(@Nonnull
                              TimeIntervalCollection collection)
```
    Initializes a new interval collection by copying an existing one.
    The new collection will not be IsFrozen (get), even if the original was.
    
    Parameters:
    
    collection - The existing collection to copy.
  - TimeIntervalCollection
```
public TimeIntervalCollection(@Nonnull
                              TimeInterval interval)
```
    Initializes a new instance from a single interval.
    
    Parameters:
    
    interval - The interval to add to the collection.
- Method Detail
  - freeze
```
public final void freeze()
```
    Freezes this object. Further attempts to modify this object will result in an ObjectFrozenException.
    
    Specified by:
    
    freeze in interface IFreezable
  - getIsFrozen
```
public final boolean getIsFrozen()
```
    Gets a value indicating whether this object is frozen. A frozen object cannot be modified and an ObjectFrozenException will be thrown if an attempt is made to do so.
    
    Specified by:
    
    getIsFrozen in interface IFreezable
  - getEmpty
```
@Nonnull
public static TimeIntervalCollection getEmpty()
```
    Gets an empty, read-only TimeIntervalCollection.
  - getInfinite
```
@Nonnull
public static TimeIntervalCollection getInfinite()
```
    Gets an unbounded, infinite, read-only TimeIntervalCollection.
  - add
```
public final void add(@Nullable
                      TimeIntervalCollection collection)
```
    Adds another interval collection to this interval collection. This interval collection will contain all intervals that were previously in either collection.
    
    Parameters:
    
    collection - The collection to add to this collection. This parameter can be null, in which case nothing will be added.
    
    Throws:
    
    ObjectFrozenException - Thrown when this TimeIntervalCollection is read-only.
  - add
```
public final boolean add(@Nonnull
                         TimeInterval item)
```
    Adds an interval to the interval collection.
    
    Specified by:
    
    add in interface Collection<TimeInterval>
    
    Specified by:
    
    add in interface List<TimeInterval>
    
    Parameters:
    
    item - The interval to add.
    
    Returns:
    
    true (as specified by Collection.add(E))
    
    Throws:
    
    ObjectFrozenException - Thrown when this TimeIntervalCollection is read-only.
  - intersect
```
@Nonnull
public final TimeIntervalCollection intersect(@Nonnull
                                                        TimeInterval interval)
```
    Computes the intersection of this interval collection with an interval.
    The returned collection will only contain the intervals that are in both collections.
    
    Parameters:
    
    interval - The interval to intersect with this collection
    
    Returns:
    
    The intersection of this collection with the interval.
  - intersect
```
@Nonnull
public final TimeIntervalCollection intersect(@Nullable
                                                        TimeIntervalCollection collection)
```
    Computes the intersection of this interval collection with another.
    The returned collection will only contain the intervals that are in both collections.
    
    Parameters:
    
    collection - The collection to intersect with this collection. The parameter can be null, in which case Intersect returns this instance.
    
    Returns:
    
    The intersection of this collection with another collection.
  - clear
```
public final void clear()
```
    Removes all intervals from the interval collection.
    
    Specified by:
    
    clear in interface Collection<TimeInterval>
    
    Specified by:
    
    clear in interface List<TimeInterval>
    
    Throws:
    
    ObjectFrozenException - Thrown when this TimeIntervalCollection is read-only.
  - getIsEmpty
```
public final boolean getIsEmpty()
```
    Gets a value indicating whether this interval collection is empty, where emptiness is defined as the count of intervals being equal to zero. To determine if the amount of time contained in this interval collection is zero, convert to a duration using TimeIntervalCollection.toDuration() and check for equality with Zero (get).
  - getIsInfinite
```
public final boolean getIsInfinite()
```
    Gets a value indicating whether the interval collection is infinite. An infinite interval collection contains all possible times.
  - indexOf
```
public final int indexOf(Object item)
```
    Finds the index of a given TimeInterval in the collection. This method requires that the given interval exactly match an interval in the collection. Intervals with different time standards or even slightly different values due to floating point noise will be considered to be different.
    
    Specified by:
    
    indexOf in interface List<TimeInterval>
    
    Parameters:
    
    item - The interval to find.
    
    Returns:
    
    The index of the interval, or -1 if the interval does not exist in the collection.
  - indexOf
```
public final int indexOf(@Nonnull
                         JulianDate date)
```
    Finds the index of the TimeInterval in this collection that contains the specified date.
    
    Parameters:
    
    date - The Julian date to find.
    
    Returns:
    
    The index of the interval that contains the date, if the date exists in the collection; otherwise, a negative number that is the bitwise complement of the index of the next interval that starts after date, or if no interval starts after the specified date, the bitwise complement of Count (get).
  - findIntervalContainingDate
```
@Nullable
public final TimeInterval findIntervalContainingDate(@Nonnull
                                                                JulianDate date)
```
    Finds the TimeInterval in this collection that contains a specified date.
    
    Parameters:
    
    date - The date to look for in the collection.
    
    Returns:
    
    The TimeInterval in the collection that contains the date, or null if the collection does not contain the date at all.
  - contains
```
public final boolean contains(@Nonnull
                              JulianDate date)
```
    Determines if the collection contains a specified date.
    
    Parameters:
    
    date - The date to look for in the collection.
    
    Returns:
    
    true if this interval collection contains the specified date; otherwise false.
  - contains
```
public final boolean contains(@Nonnull
                              Object item)
```
    Determines if this collection contains all of a specified interval.
    
    Specified by:
    
    contains in interface Collection<TimeInterval>
    
    Specified by:
    
    contains in interface List<TimeInterval>
    
    Parameters:
    
    item - The interval to check.
    
    Returns:
    
    true if this interval collection contains the specified interval, or false if this collection has any gaps over the input interval.
  - copyTo
```
public final void copyTo(TimeInterval[] array,
                         int arrayIndex)
```
    Copies the intervals in this collection to an array.
    
    Parameters:
    
    array - The destination array.
    
    arrayIndex - The index at which to begin copying.
  - size
```
public final int size()
```
    Gets the number of intervals in this interval collection.
    
    Specified by:
    
    size in interface Collection<TimeInterval>
    
    Specified by:
    
    size in interface List<TimeInterval>
    
    Returns:
    
    the number of elements in this list
  - remove
```
public final boolean remove(@Nonnull
                            TimeIntervalCollection collection)
```
    Removes the specified intervals from this interval list, creating a hole over the specified intervals.
    
    Parameters:
    
    collection - The interval collection to remove.
    
    Returns:
    
    true if any part of the input interval collection was in the interval collection; otherwise false.
  - remove
```
public final TimeInterval remove(int index)
```
    Removes the interval at a specified index in the collection.
    
    Specified by:
    
    remove in interface List<TimeInterval>
    
    Parameters:
    
    index - The index of the interval to remove.
    
    Returns:
    
    the element previously at the specified position
  - remove
```
public final boolean remove(@Nonnull
                            Object item)
```
    Removes the specified interval from this interval list, creating a hole over the specified interval.
    
    Specified by:
    
    remove in interface Collection<TimeInterval>
    
    Specified by:
    
    remove in interface List<TimeInterval>
    
    Parameters:
    
    item - The interval to remove.
    
    Returns:
    
    true if any part of the input interval was in the interval list; otherwise false.
    
    Throws:
    
    ObjectFrozenException - Thrown when this TimeIntervalCollection is read-only.
  - removeLeavingEndpoints
```
public final boolean removeLeavingEndpoints(@Nonnull
                                            TimeIntervalCollection collection)
```
    Removes the specified intervals from this interval list, creating a hole over the specified intervals. The end points of the removed intervals are NOT removed.
    
    Parameters:
    
    collection - The interval collection to remove.
    
    Returns:
    
    true if any part of the input interval collection was in the interval collection; otherwise false.
  - removeLeavingEndpoints
```
public final boolean removeLeavingEndpoints(@Nonnull
                                            TimeInterval item)
```
    Removes the specified interval from this interval list, creating a hole over the specified interval. The end points of the removed interval are NOT removed.
    
    Parameters:
    
    item - The interval to remove.
    
    Returns:
    
    true if any part of the input interval was in the interval list; otherwise false.
    
    Throws:
    
    ObjectFrozenException - Thrown when this TimeIntervalCollection is read-only.
  - complement
```
@Nonnull
public final TimeIntervalCollection complement(@Nonnull
                                                         JulianDate startDate,
                                                         @Nonnull
                                                         JulianDate endDate)
```
    Computes the complement of this time interval collection.
    
    The new TimeIntervalCollection is the complement of this TimeIntervalCollection within the given startDate and endDate bounds. In other words, the new TimeIntervalCollection will represent all dates that are between the start and end dates and that were NOT present in the original collection. Any dates before the given startDate and after the given endDate are removed.
    
    Parameters:
    
    startDate - The earliest date to include in the complement.
    
    endDate - The latest date to include in the complement.
    
    Returns:
    
    The complement of this instance.
  - toTimeStandard
```
@Nonnull
public final TimeIntervalCollection toTimeStandard(TimeStandard timeStandard)
```
    Converts all times in this time interval collection to be the specified time standard.
    
    Parameters:
    
    timeStandard - The time standard to use.
    
    Returns:
    
    A copy of this collection with the new time standard.
  - iterator
```
public final Iterator<TimeInterval> iterator()
```
    Gets an enumerator for this interval list.
    
    Specified by:
    
    iterator in interface Iterable<TimeInterval>
    
    Specified by:
    
    iterator in interface Collection<TimeInterval>
    
    Specified by:
    
    iterator in interface List<TimeInterval>
    
    Returns:
    
    An enumerator for enumerating the intervals in this collection.
  - get
```
public final TimeInterval get(int index)
```
    Gets the interval at the specified index.
    
    Specified by:
    
    get in interface List<TimeInterval>
    
    Parameters:
    
    index - The index.
    
    Returns:
    
    the element at the specified position in this list
  - set
```
public final TimeInterval set(int index,
                              TimeInterval value)
```
    Sets the interval at the specified index.
    
    Specified by:
    
    set in interface List<TimeInterval>
    
    Parameters:
    
    index - The index.
    
    value - element to be stored at the specified position
    
    Returns:
    
    the element previously at the specified position
  - getStart
```
@Nonnull
public final JulianDate getStart()
```
    Gets the start date of the first interval in the collection.
  - getStop
```
@Nonnull
public final JulianDate getStop()
```
    Gets the stop date of the last interval in the collection
  - toDuration
```
@Nonnull
public final Duration toDuration()
```
    Returns a Duration representing the span of time represented by the sum of the individual time intervals in the collection.
    
    Returns:
    
    The total duration.
  - toString
```
public String toString()
```
    Description copied from class: java.lang.Object
    Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
    The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
    getClass().getName() + '@' + Integer.toHexString(hashCode())
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of the object.
  - equalsType
```
public final boolean equalsType(TimeIntervalCollection other)
```
    Indicates whether another instance of this type is exactly equal to this instance.
    In order for two collections to be considered equal, each TimeInterval in one collection must be equal to the TimeInterval at the same index in the other collection.
    
    Specified by:
    
    equalsType in interface IEquatable<TimeIntervalCollection>
    
    Parameters:
    
    other - The instance to compare to this instance.
    
    Returns:
    
    true if other represents the same value as this instance; otherwise false.
  - hashCode
```
public int hashCode()
```
    Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.
    
    Specified by:
    
    hashCode in interface Collection<TimeInterval>
    
    Specified by:
    
    hashCode in interface List<TimeInterval>
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    A hash code for the current object.
    
    See Also:
    
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object obj)
```
    Indicates whether another object is exactly equal to this instance.
    In order for two collections to be considered equal, each TimeInterval in one collection must be equal to the TimeInterval at the same index in the other collection.
    
    Specified by:
    
    equals in interface Collection<TimeInterval>
    
    Specified by:
    
    equals in interface List<TimeInterval>
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - The object to compare to this instance.
    
    Returns:
    
    true if obj is an instance of this type and represents the same value as this instance; otherwise false.
    
    See Also:
    
    Object.hashCode(), HashMap
  - equals
```
public static boolean equals(TimeIntervalCollection left,
                             TimeIntervalCollection right)
```
    Returns true if the two instances are exactly equal.
    In order for two collections to be considered equal, each TimeInterval in one collection must be equal to the TimeInterval at the same index in the other collection.
    
    Parameters:
    
    left - The instance to compare to right.
    
    right - The instance to compare to left.
    
    Returns:
    
    true if left represents the same value as right; otherwise false.
  - notEquals
```
public static boolean notEquals(TimeIntervalCollection left,
                                TimeIntervalCollection right)
```
    Returns true if the two instances are not exactly equal.
    In order for two collections to be considered equal, each TimeInterval in one collection must be equal to the TimeInterval at the same index in the other collection.
    
    Parameters:
    
    left - The instance to compare to right.
    
    right - The instance to compare to left.
    
    Returns:
    
    true if left does not represent the same value as right; otherwise false.
  - equalsEpsilon
```
public final boolean equalsEpsilon(TimeIntervalCollection other,
                                   double epsilon)
```
    Determines if this TimeIntervalCollection is equal to another by comparing each of the TimeInterval elements in the two collections with TimeInterval.equalsEpsilon(agi.foundation.time.TimeInterval, double).
    
    Specified by:
    
    equalsEpsilon in interface IEquatableEpsilon<TimeIntervalCollection>
    
    Parameters:
    
    other - A TimeIntervalCollection to compare this one to.
    
    epsilon - The largest difference between the Start and Stop dates, in seconds, such that they will be considered equal.
    
    Returns:
    
    True if all TimeIntervals are equal as defined by the epsilon value.
  - addData
```
@Nonnull
public final <T> TimeIntervalCollection1<T> addData(T data)
```
    Converts this collection to a TimeIntervalCollection1 by filling in the Data (get) property for all intervals.
    
    Type Parameters:
    
    T - The type of the data.
    
    Parameters:
    
    data - The value of the Data (get) property for all intervals in the new collection.
    
    Returns:
    
    A collection equivalent to this one, with data.
  - add
```
public final void add(int index,
                      TimeInterval item)
```
    Adds a time interval to the list. This method is identical to TimeIntervalCollection.add(TimeInterval) - the index parameter is ignored.
    
    Specified by:
    
    add in interface List<TimeInterval>
    
    Parameters:
    
    index - Ignored.
    
    item - The interval to add to this collection.
  - isEmpty
```
public final boolean isEmpty()
```
    Description copied from interface: java.util.List
    
    Returns true if this list contains no elements.
    
    Specified by:
    
    isEmpty in interface Collection<TimeInterval>
    
    Specified by:
    
    isEmpty in interface List<TimeInterval>
    
    Returns:
    
    true if this list contains no elements
  - addAll
```
public final boolean addAll(Collection<? extends TimeInterval> c)
```
    Description copied from interface: java.util.List
    
    Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (Note that this will occur if the specified collection is this list, and it's nonempty.)
    
    Specified by:
    
    addAll in interface Collection<TimeInterval>
    
    Specified by:
    
    addAll in interface List<TimeInterval>
    
    Parameters:
    
    c - collection containing elements to be added to this list
    
    Returns:
    
    true if this list changed as a result of the call
    
    See Also:
    
    List.add(Object)
  - addAll
```
public final boolean addAll(int index,
                            Collection<? extends TimeInterval> c)
```
    Description copied from interface: java.util.List
    
    Inserts all of the elements in the specified collection into this list at the specified position (optional operation). Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in this list in the order that they are returned by the specified collection's iterator. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (Note that this will occur if the specified collection is this list, and it's nonempty.)
    
    Specified by:
    
    addAll in interface List<TimeInterval>
    
    Parameters:
    
    index - index at which to insert the first element from the specified collection
    
    c - collection containing elements to be added to this list
    
    Returns:
    
    true if this list changed as a result of the call
  - containsAll
```
public final boolean containsAll(Collection<?> c)
```
    Description copied from interface: java.util.List
    
    Returns true if this list contains all of the elements of the specified collection.
    
    Specified by:
    
    containsAll in interface Collection<TimeInterval>
    
    Specified by:
    
    containsAll in interface List<TimeInterval>
    
    Parameters:
    
    c - collection to be checked for containment in this list
    
    Returns:
    
    true if this list contains all of the elements of the specified collection
    
    See Also:
    
    List.contains(Object)
  - toArray
```
public final Object[] toArray()
```
    Description copied from interface: java.util.List
    
    Returns an array containing all of the elements in this list in proper sequence (from first to last element).
    The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array even if this list is backed by an array). The caller is thus free to modify the returned array.
    This method acts as bridge between array-based and collection-based APIs.
    
    Specified by:
    
    toArray in interface Collection<TimeInterval>
    
    Specified by:
    
    toArray in interface List<TimeInterval>
    
    Returns:
    
    an array containing all of the elements in this list in proper sequence
    
    See Also:
    
    Arrays.asList(Object[])
  - toArray
```
public final <T> T[] toArray(T[] a)
```
    Description copied from interface: java.util.List
    Returns an array containing all of the elements in this list in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array. If the list fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this list.
    If the list fits in the specified array with room to spare (i.e., the array has more elements than the list), the element in the array immediately following the end of the list is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)
    Like the List.toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.
    Suppose x is a list known to contain only strings. The following code can be used to dump the list into a newly allocated array of String:
```
     String[] y = x.toArray(new String[0]);
 
```
    Note that toArray(new Object[0]) is identical in function to toArray().
    Specified by:
    
    toArray in interface Collection<TimeInterval>
    
    Specified by:
    
    toArray in interface List<TimeInterval>
    
    Type Parameters:
    
    T - the runtime type of the array to contain the collection
    
    Parameters:
    
    a - the array into which the elements of this list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
    
    Returns:
    
    an array containing the elements of this list
  - lastIndexOf
```
public final int lastIndexOf(Object o)
```
    Description copied from interface: java.util.List
    
    Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the highest index i such that (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is no such index.
    
    Specified by:
    
    lastIndexOf in interface List<TimeInterval>
    
    Parameters:
    
    o - element to search for
    
    Returns:
    
    the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element
  - listIterator
```
public final ListIterator<TimeInterval> listIterator()
```
    Description copied from interface: java.util.List
    
    Returns a list iterator over the elements in this list (in proper sequence).
    
    Specified by:
    
    listIterator in interface List<TimeInterval>
    
    Returns:
    
    a list iterator over the elements in this list (in proper sequence)
  - listIterator
```
public final ListIterator<TimeInterval> listIterator(int index)
```
    Description copied from interface: java.util.List
    
    Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.
    
    Specified by:
    
    listIterator in interface List<TimeInterval>
    
    Parameters:
    
    index - index of the first element to be returned from the list iterator (by a call to next)
    
    Returns:
    
    a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list
  - subList
```
public final List<TimeInterval> subList(int fromIndex,
                                        int toIndex)
```
    Description copied from interface: java.util.List
    Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned list is empty.) The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations supported by this list.
    This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:
```
      list.subList(from, to).clear();
 
```
    Similar idioms may be constructed for indexOf and lastIndexOf, and all of the algorithms in the Collections class can be applied to a subList.
    The semantics of the list returned by this method become undefined if the backing list (i.e., this list) is structurally modified in any way other than via the returned list. (Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.)
    Specified by:
    
    subList in interface List<TimeInterval>
    
    Parameters:
    
    fromIndex - low endpoint (inclusive) of the subList
    
    toIndex - high endpoint (exclusive) of the subList
    
    Returns:
    
    a view of the specified range within this list
  - removeAll
```
public final boolean removeAll(Collection<?> c)
```
    Description copied from interface: java.util.List
    
    Removes from this list all of its elements that are contained in the specified collection (optional operation).
    
    Specified by:
    
    removeAll in interface Collection<TimeInterval>
    
    Specified by:
    
    removeAll in interface List<TimeInterval>
    
    Parameters:
    
    c - collection containing elements to be removed from this list
    
    Returns:
    
    true if this list changed as a result of the call
    
    See Also:
    
    List.remove(Object), List.contains(Object)
  - retainAll
```
public final boolean retainAll(Collection<?> c)
```
    Description copied from interface: java.util.List
    
    Retains only the elements in this list that are contained in the specified collection (optional operation). In other words, removes from this list all of its elements that are not contained in the specified collection.
    
    Specified by:
    
    retainAll in interface Collection<TimeInterval>
    
    Specified by:
    
    retainAll in interface List<TimeInterval>
    
    Parameters:
    
    c - collection containing elements to be retained in this list
    
    Returns:
    
    true if this list changed as a result of the call
    
    See Also:
    
    List.remove(Object), List.contains(Object)

Class TimeIntervalCollection

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Constructor Detail

TimeIntervalCollection

TimeIntervalCollection

Method Detail

freeze

getIsFrozen

getEmpty

getInfinite

add

add

intersect

intersect

clear

getIsEmpty

getIsInfinite

indexOf

indexOf

findIntervalContainingDate

contains

contains

copyTo

size

remove

remove

remove

removeLeavingEndpoints

removeLeavingEndpoints

complement

toTimeStandard

iterator

get

set

getStart

getStop

toDuration

toString

equalsType

hashCode

equals

equals

notEquals

equalsEpsilon

addData

add

isEmpty

addAll

addAll

containsAll

toArray

toArray

lastIndexOf

listIterator

listIterator

subList

removeAll

retainAll