edu.stanford.nlp.util
Class IntervalTree<E extends java.lang.Comparable<E>,T extends HasInterval<E>>

java.lang.Object
  edu.stanford.nlp.util.IntervalTree<E,T>

public class IntervalTree<E extends java.lang.Comparable<E>,T extends HasInterval<E>>
extends java.lang.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

IntervalTree()

Method Summary

void	add(T target)
void	addAll(java.util.Collection<T> c)
boolean	addNonNested(T target)
boolean	addNonOverlapping(T target)
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> boolean	contains(IntervalTree<E,T> n, E p)
static <E extends java.lang.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 java.lang.Comparable<E>> java.util.List<T>	getNonNested(java.util.List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, java.util.Comparator<? super T> compareFunc)
static <T extends HasInterval<E>,E extends java.lang.Comparable<E>> java.util.List<T>	getNonOverlapping(java.util.List<? extends T> items)
static <T extends HasInterval<E>,E extends java.lang.Comparable<E>> java.util.List<T>	getNonOverlapping(java.util.List<? extends T> items, java.util.Comparator<? super T> compareFunc)
static <T,E extends java.lang.Comparable<E>> java.util.List<T>	getNonOverlapping(java.util.List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc)
static <T,E extends java.lang.Comparable<E>> java.util.List<T>	getNonOverlapping(java.util.List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, java.util.Comparator<? super T> compareFunc)
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> java.util.List<T>	getOverlapping(IntervalTree<E,T> n, E p)
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> void	getOverlapping(IntervalTree<E,T> n, E p, java.util.List<T> result)
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> java.util.List<T>	getOverlapping(IntervalTree<E,T> n, Interval<E> target)
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> void	getOverlapping(IntervalTree<E,T> n, Interval<E> target, java.util.List<T> result)
java.util.List<T>	getOverlapping(T target)
IntervalTree<E,T>	getRightmostNode()
boolean	isEmpty()
static <E extends java.lang.Comparable<E>,T extends HasInterval<E>> boolean	overlaps(IntervalTree<E,T> n, E p)
static <E extends java.lang.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(java.util.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 java.util.List<T> getOverlapping(T target)

getOverlapping

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

getOverlapping

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

getOverlapping

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

getOverlapping

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

overlaps

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

overlaps

public static <E extends java.lang.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 java.lang.Comparable<E>,T extends HasInterval<E>> boolean contains(IntervalTree<E,T> n,
                                                                                            E p)

contains

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

getNonOverlapping

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

getNonOverlapping

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

getNonOverlapping

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

getNonOverlapping

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

getNonNested

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