edu.stanford.nlp.util

Class IntervalTree<E extends Comparable<E>,T extends HasInterval<E>>

java.lang.Object

edu.stanford.nlp.util.IntervalTree<E,T>

public class IntervalTree<E extends Comparable<E>,T extends HasInterval<E>>
extends Object

Interval tree Maintain tree so all intervals to the left starts before current interval and all intervals to the right starts after

Author:

Angel Chang

Constructor Summary

Constructors

Constructor and Description
IntervalTree()

Method Summary

Methods

Modifier and Type	Method and Description
void	add(T target)
void	addAll(Collection<T> c)
boolean	addNonNested(T target)
boolean	addNonOverlapping(T target)
static <E extends Comparable<E>,T extends HasInterval<E>> boolean	contains(IntervalTree<E,T> n, E p)
static <E extends Comparable<E>,T extends HasInterval<E>> boolean	contains(IntervalTree<E,T> n, Interval<E> target)
boolean	contains(T target)
IntervalTree<E,T>	getLeftmostNode()
static <T,E extends Comparable<E>> List<T>	getNonNested(List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc)
static <T extends HasInterval<E>,E extends Comparable<E>> List<T>	getNonOverlapping(List<? extends T> items)
static <T extends HasInterval<E>,E extends Comparable<E>> List<T>	getNonOverlapping(List<? extends T> items, Comparator<? super T> compareFunc)
static <T,E extends Comparable<E>> List<T>	getNonOverlapping(List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc)
static <T,E extends Comparable<E>> List<T>	getNonOverlapping(List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc)
static <E extends Comparable<E>,T extends HasInterval<E>> List<T>	getOverlapping(IntervalTree<E,T> n, E p)
static <E extends Comparable<E>,T extends HasInterval<E>> void	getOverlapping(IntervalTree<E,T> n, E p, List<T> result)
static <E extends Comparable<E>,T extends HasInterval<E>> List<T>	getOverlapping(IntervalTree<E,T> n, Interval<E> target)
static <E extends Comparable<E>,T extends HasInterval<E>> void	getOverlapping(IntervalTree<E,T> n, Interval<E> target, List<T> result)
List<T>	getOverlapping(T target)
IntervalTree<E,T>	getRightmostNode()
boolean	isEmpty()
static <E extends Comparable<E>,T extends HasInterval<E>> boolean	overlaps(IntervalTree<E,T> n, E p)
static <E extends Comparable<E>,T extends HasInterval<E>> boolean	overlaps(IntervalTree<E,T> n, Interval<E> target)
boolean	overlaps(T target)
boolean	remove(T target)
int	size()

Methods inherited from class java.lang.Object

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

Constructor Detail

IntervalTree

public IntervalTree()

Method Detail

isEmpty

public boolean isEmpty()

addAll

public void addAll(Collection<T> c)

add

public void add(T target)

size

public int size()

remove

public boolean remove(T target)

getLeftmostNode

public IntervalTree<E,T> getLeftmostNode()

getRightmostNode

public IntervalTree<E,T> getRightmostNode()

addNonOverlapping

public boolean addNonOverlapping(T target)

addNonNested

public boolean addNonNested(T target)

overlaps

public boolean overlaps(T target)

getOverlapping

public List<T> getOverlapping(T target)

getOverlapping

public static <E extends Comparable<E>,T extends HasInterval<E>> List<T> getOverlapping(IntervalTree<E,T> n,
                                                                        E p)

getOverlapping

public static <E extends Comparable<E>,T extends HasInterval<E>> List<T> getOverlapping(IntervalTree<E,T> n,
                                                                        Interval<E> target)

getOverlapping

public static <E extends Comparable<E>,T extends HasInterval<E>> void getOverlapping(IntervalTree<E,T> n,
                                                                     E p,
                                                                     List<T> result)

getOverlapping

public static <E extends Comparable<E>,T extends HasInterval<E>> void getOverlapping(IntervalTree<E,T> n,
                                                                     Interval<E> target,
                                                                     List<T> result)

overlaps

public static <E extends Comparable<E>,T extends HasInterval<E>> boolean overlaps(IntervalTree<E,T> n,
                                                                  E p)

overlaps

public static <E extends Comparable<E>,T extends HasInterval<E>> boolean overlaps(IntervalTree<E,T> n,
                                                                  Interval<E> target)

contains

public boolean contains(T target)

contains

public static <E extends Comparable<E>,T extends HasInterval<E>> boolean contains(IntervalTree<E,T> n,
                                                                  E p)

contains

public static <E extends Comparable<E>,T extends HasInterval<E>> boolean contains(IntervalTree<E,T> n,
                                                                  Interval<E> target)

getNonOverlapping

public static <T,E extends Comparable<E>> List<T> getNonOverlapping(List<? extends T> items,
                                                    Function<? super T,Interval<E>> toIntervalFunc)

getNonOverlapping

public static <T,E extends Comparable<E>> List<T> getNonOverlapping(List<? extends T> items,
                                                    Function<? super T,Interval<E>> toIntervalFunc,
                                                    Comparator<? super T> compareFunc)

getNonOverlapping

public static <T extends HasInterval<E>,E extends Comparable<E>> List<T> getNonOverlapping(List<? extends T> items,
                                                                           Comparator<? super T> compareFunc)

getNonOverlapping

public static <T extends HasInterval<E>,E extends Comparable<E>> List<T> getNonOverlapping(List<? extends T> items)

getNonNested

public static <T,E extends Comparable<E>> List<T> getNonNested(List<? extends T> items,
                                               Function<? super T,Interval<E>> toIntervalFunc,
                                               Comparator<? super T> compareFunc)