Package org.usf.java.jinterval.core

Class Intervals

java.lang.Object

org.usf.java.jinterval.core.Intervals

public final class Intervals
extends Object

Constructor Summary

Constructors

Constructor	Description
Intervals()

Method Summary

Modifier and Type	Method	Description
static <T extends Comparable<? super T>> void	acceptIf(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals, java.util.function.IntPredicate nIntervalPredicate, java.util.function.BiConsumer<T,T> consumer)
static <T extends Comparable<? super T>,I,R> R	collectMissingAndOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)
static <T extends Comparable<? super T>,I,R> R	collectMissingAndOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)
static <T extends Comparable<? super T>,I,R> R	collectMissingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)	collect
static <T extends Comparable<? super T>,I,R> R	collectMissingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)
static <T extends Comparable<? super T>,I,R> R	collectOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)
static <T extends Comparable<? super T>,I,R> R	collectOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,?,R> collector)
static <T extends Comparable<? super T>,I,C,R> R	filter(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals, java.util.function.IntPredicate intervalCount, java.util.function.BiFunction<T,T,I> fn, java.util.stream.Collector<I,C,R> collector)
static <T extends Comparable<? super T>> boolean	isMissingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)	testIf
static <T extends Comparable<? super T>> boolean	isMissingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> boolean	isMissingOrOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> boolean	isMissingOrOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> boolean	isOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> boolean	isOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> Optional<Interval<T>>	maxInterval(Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> Optional<Interval<T>>	minInterval(Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> List<Interval<T>>	missingAndOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> List<Interval<T>>	missingAndOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> List<Interval<T>>	missingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)	filter
static <T extends Comparable<? super T>> List<Interval<T>>	missingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> List<Interval<T>>	overlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> List<Interval<T>>	overlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> void	requiredNotMissingAndOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> void	requiredNotMissingAndOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> void	requiredNotMissingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)	throwsIf
static <T extends Comparable<? super T>> void	requiredNotMissingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> void	requiredNotOverlappingIntervals(boolean reversed, Collection<? extends Interval<T>> intervals)
static <T extends Comparable<? super T>> void	requiredNotOverlappingIntervals(boolean reversed, T start, T exclusifEnd, Collection<? extends Interval<T>> intervals)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Intervals

public Intervals()

Method Detail

minInterval

public static <T extends Comparable<? super T>> Optional<Interval<T>> minInterval(Collection<? extends Interval<T>> intervals)

maxInterval

public static <T extends Comparable<? super T>> Optional<Interval<T>> maxInterval(Collection<? extends Interval<T>> intervals)

isMissingIntervals

public static <T extends Comparable<? super T>> boolean isMissingIntervals(boolean reversed,
                                                                           Collection<? extends Interval<T>> intervals)

testIf

isMissingIntervals

public static <T extends Comparable<? super T>> boolean isMissingIntervals(boolean reversed,
                                                                           T start,
                                                                           T exclusifEnd,
                                                                           Collection<? extends Interval<T>> intervals)

isOverlappingIntervals

public static <T extends Comparable<? super T>> boolean isOverlappingIntervals(boolean reversed,
                                                                               Collection<? extends Interval<T>> intervals)

isOverlappingIntervals

public static <T extends Comparable<? super T>> boolean isOverlappingIntervals(boolean reversed,
                                                                               T start,
                                                                               T exclusifEnd,
                                                                               Collection<? extends Interval<T>> intervals)

isMissingOrOverlappingIntervals

public static <T extends Comparable<? super T>> boolean isMissingOrOverlappingIntervals(boolean reversed,
                                                                                        Collection<? extends Interval<T>> intervals)

isMissingOrOverlappingIntervals

public static <T extends Comparable<? super T>> boolean isMissingOrOverlappingIntervals(boolean reversed,
                                                                                        T start,
                                                                                        T exclusifEnd,
                                                                                        Collection<? extends Interval<T>> intervals)

requiredNotMissingIntervals

public static <T extends Comparable<? super T>> void requiredNotMissingIntervals(boolean reversed,
                                                                                 Collection<? extends Interval<T>> intervals)

throwsIf

requiredNotMissingIntervals

public static <T extends Comparable<? super T>> void requiredNotMissingIntervals(boolean reversed,
                                                                                 T start,
                                                                                 T exclusifEnd,
                                                                                 Collection<? extends Interval<T>> intervals)

requiredNotOverlappingIntervals

public static <T extends Comparable<? super T>> void requiredNotOverlappingIntervals(boolean reversed,
                                                                                     Collection<? extends Interval<T>> intervals)

requiredNotOverlappingIntervals

public static <T extends Comparable<? super T>> void requiredNotOverlappingIntervals(boolean reversed,
                                                                                     T start,
                                                                                     T exclusifEnd,
                                                                                     Collection<? extends Interval<T>> intervals)

requiredNotMissingAndOverlappingIntervals

public static <T extends Comparable<? super T>> void requiredNotMissingAndOverlappingIntervals(boolean reversed,
                                                                                               Collection<? extends Interval<T>> intervals)

requiredNotMissingAndOverlappingIntervals

public static <T extends Comparable<? super T>> void requiredNotMissingAndOverlappingIntervals(boolean reversed,
                                                                                               T start,
                                                                                               T exclusifEnd,
                                                                                               Collection<? extends Interval<T>> intervals)

missingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> missingIntervals(boolean reversed,
                                                                                   Collection<? extends Interval<T>> intervals)

filter

missingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> missingIntervals(boolean reversed,
                                                                                   T start,
                                                                                   T exclusifEnd,
                                                                                   Collection<? extends Interval<T>> intervals)

overlappingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> overlappingIntervals(boolean reversed,
                                                                                       Collection<? extends Interval<T>> intervals)

overlappingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> overlappingIntervals(boolean reversed,
                                                                                       T start,
                                                                                       T exclusifEnd,
                                                                                       Collection<? extends Interval<T>> intervals)

missingAndOverlappingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> missingAndOverlappingIntervals(boolean reversed,
                                                                                                 Collection<? extends Interval<T>> intervals)

missingAndOverlappingIntervals

public static <T extends Comparable<? super T>> List<Interval<T>> missingAndOverlappingIntervals(boolean reversed,
                                                                                                 T start,
                                                                                                 T exclusifEnd,
                                                                                                 Collection<? extends Interval<T>> intervals)

collectMissingIntervals

public static <T extends Comparable<? super T>,I,R> R collectMissingIntervals(boolean reversed,
                                                                                          Collection<? extends Interval<T>> intervals,
                                                                                          java.util.function.BiFunction<T,T,I> fn,
                                                                                          java.util.stream.Collector<I,?,R> collector)

collect

collectMissingIntervals

public static <T extends Comparable<? super T>,I,R> R collectMissingIntervals(boolean reversed,
                                                                                          T start,
                                                                                          T exclusifEnd,
                                                                                          Collection<? extends Interval<T>> intervals,
                                                                                          java.util.function.BiFunction<T,T,I> fn,
                                                                                          java.util.stream.Collector<I,?,R> collector)

collectOverlappingIntervals

public static <T extends Comparable<? super T>,I,R> R collectOverlappingIntervals(boolean reversed,
                                                                                              Collection<? extends Interval<T>> intervals,
                                                                                              java.util.function.BiFunction<T,T,I> fn,
                                                                                              java.util.stream.Collector<I,?,R> collector)

collectOverlappingIntervals

public static <T extends Comparable<? super T>,I,R> R collectOverlappingIntervals(boolean reversed,
                                                                                              T start,
                                                                                              T exclusifEnd,
                                                                                              Collection<? extends Interval<T>> intervals,
                                                                                              java.util.function.BiFunction<T,T,I> fn,
                                                                                              java.util.stream.Collector<I,?,R> collector)

collectMissingAndOverlappingIntervals

public static <T extends Comparable<? super T>,I,R> R collectMissingAndOverlappingIntervals(boolean reversed,
                                                                                                        Collection<? extends Interval<T>> intervals,
                                                                                                        java.util.function.BiFunction<T,T,I> fn,
                                                                                                        java.util.stream.Collector<I,?,R> collector)

collectMissingAndOverlappingIntervals

public static <T extends Comparable<? super T>,I,R> R collectMissingAndOverlappingIntervals(boolean reversed,
                                                                                                        T start,
                                                                                                        T exclusifEnd,
                                                                                                        Collection<? extends Interval<T>> intervals,
                                                                                                        java.util.function.BiFunction<T,T,I> fn,
                                                                                                        java.util.stream.Collector<I,?,R> collector)

filter

public static <T extends Comparable<? super T>,I,C,R> R filter(boolean reversed,
                                                                                 T start,
                                                                                 T exclusifEnd,
                                                                                 Collection<? extends Interval<T>> intervals,
                                                                                 java.util.function.IntPredicate intervalCount,
                                                                                 java.util.function.BiFunction<T,T,I> fn,
                                                                                 java.util.stream.Collector<I,C,R> collector)

acceptIf

public static <T extends Comparable<? super T>> void acceptIf(boolean reversed,
                                                              T start,
                                                              T exclusifEnd,
                                                              Collection<? extends Interval<T>> intervals,
                                                              java.util.function.IntPredicate nIntervalPredicate,
                                                              java.util.function.BiConsumer<T,T> consumer)