Cross Reference: /external/guava/guava/src/com/google/common/collect/TreeRangeSet.java

Lines Matching refs:Range
48   final NavigableMap<Cut<C>, Range<C>> rangesByLowerBound;
54     return new TreeRangeSet<C>(new TreeMap<Cut<C>, Range<C>>());
66   private TreeRangeSet(NavigableMap<Cut<C>, Range<C>> rangesByLowerCut) {
70   private transient Set<Range<C>> asRanges;
73   public Set<Range<C>> asRanges() {
74     Set<Range<C>> result = asRanges;
78   final class AsRanges extends ForwardingCollection<Range<C>> implements Set<Range<C>> {
80     protected Collection<Range<C>> delegate() {
97   public Range<C> rangeContaining(C value) {
99     Entry<Cut<C>, Range<C>> floorEntry = rangesByLowerBound.floorEntry(Cut.belowValue(value));
109   public boolean encloses(Range<C> range) {
111     Entry<Cut<C>, Range<C>> floorEntry = rangesByLowerBound.floorEntry(range.lowerBound);
116   private Range<C> rangeEnclosing(Range<C> range) {
118     Entry<Cut<C>, Range<C>> floorEntry = rangesByLowerBound.floorEntry(range.lowerBound);
125   public Range<C> span() {
126     Entry<Cut<C>, Range<C>> firstEntry = rangesByLowerBound.firstEntry();
127     Entry<Cut<C>, Range<C>> lastEntry = rangesByLowerBound.lastEntry();
131     return Range.create(firstEntry.getValue().lowerBound, lastEntry.getValue().upperBound);
135   public void add(Range<C> rangeToAdd) {
147     Entry<Cut<C>, Range<C>> entryBelowLB = rangesByLowerBound.lowerEntry(lbToAdd);
150       Range<C> rangeBelowLB = entryBelowLB.getValue();
165     Entry<Cut<C>, Range<C>> entryBelowUB = rangesByLowerBound.floorEntry(ubToAdd);
168       Range<C> rangeBelowUB = entryBelowUB.getValue();
178     replaceRangeWithSameLowerBound(Range.create(lbToAdd, ubToAdd));
182   public void remove(Range<C> rangeToRemove) {
192     Entry<Cut<C>, Range<C>> entryBelowLB = rangesByLowerBound.lowerEntry(rangeToRemove.lowerBound);
195       Range<C> rangeBelowLB = entryBelowLB.getValue();
202               Range.create(rangeToRemove.upperBound, rangeBelowLB.upperBound));
205             Range.create(rangeBelowLB.lowerBound, rangeToRemove.lowerBound));
209     Entry<Cut<C>, Range<C>> entryBelowUB = rangesByLowerBound.floorEntry(rangeToRemove.upperBound);
212       Range<C> rangeBelowUB = entryBelowUB.getValue();
217             Range.create(rangeToRemove.upperBound, rangeBelowUB.upperBound));
224   private void replaceRangeWithSameLowerBound(Range<C> range) {
242       extends AbstractNavigableMap<Cut<C>, Range<C>> {
243     private final NavigableMap<Cut<C>, Range<C>> rangesByLowerBound;
249     private final Range<Cut<C>> upperBoundWindow;
251     RangesByUpperBound(NavigableMap<Cut<C>, Range<C>> rangesByLowerBound) {
253       this.upperBoundWindow = Range.all();
257         NavigableMap<Cut<C>, Range<C>> rangesByLowerBound, Range<Cut<C>> upperBoundWindow) {
262     private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> window) {
271     public NavigableMap<Cut<C>, Range<C>> subMap(
273       return subMap(Range.range(
279     public NavigableMap<Cut<C>, Range<C>> headMap(Cut<C> toKey, boolean inclusive) {
280       return subMap(Range.upTo(toKey, BoundType.forBoolean(inclusive)));
284     public NavigableMap<Cut<C>, Range<C>> tailMap(Cut<C> fromKey, boolean inclusive) {
285       return subMap(Range.downTo(fromKey, BoundType.forBoolean(inclusive)));
299     public Range<C> get(@Nullable Object key) {
307           Entry<Cut<C>, Range<C>> candidate = rangesByLowerBound.lowerEntry(cut);
319     Iterator<Entry<Cut<C>, Range<C>>> entryIterator() {
324       final Iterator<Range<C>> backingItr;
328         Entry<Cut<C>, Range<C>> lowerEntry =
339       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
341         protected Entry<Cut<C>, Range<C>> computeNext() {
345           Range<C> range = backingItr.next();
356     Iterator<Entry<Cut<C>, Range<C>>> descendingEntryIterator() {
357       Collection<Range<C>> candidates;
364       final PeekingIterator<Range<C>> backingItr = Iterators.peekingIterator(candidates.iterator());
369       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
371         protected Entry<Cut<C>, Range<C>> computeNext() {
375           Range<C> range = backingItr.next();
385       if (upperBoundWindow.equals(Range.all())) {
393       return upperBoundWindow.equals(Range.all())
400       extends AbstractNavigableMap<Cut<C>, Range<C>> {
401     private final NavigableMap<Cut<C>, Range<C>> positiveRangesByLowerBound;
402     private final NavigableMap<Cut<C>, Range<C>> positiveRangesByUpperBound;
409     private final Range<Cut<C>> complementLowerBoundWindow;
411     ComplementRangesByLowerBound(NavigableMap<Cut<C>, Range<C>> positiveRangesByLowerBound) {
412       this(positiveRangesByLowerBound, Range.<Cut<C>>all());
415     private ComplementRangesByLowerBound(NavigableMap<Cut<C>, Range<C>> positiveRangesByLowerBound,
416         Range<Cut<C>> window) {
422     private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> subWindow) {
432     public NavigableMap<Cut<C>, Range<C>> subMap(
434       return subMap(Range.range(
440     public NavigableMap<Cut<C>, Range<C>> headMap(Cut<C> toKey, boolean inclusive) {
441       return subMap(Range.upTo(toKey, BoundType.forBoolean(inclusive)));
445     public NavigableMap<Cut<C>, Range<C>> tailMap(Cut<C> fromKey, boolean inclusive) {
446       return subMap(Range.downTo(fromKey, BoundType.forBoolean(inclusive)));
455     Iterator<Entry<Cut<C>, Range<C>>> entryIterator() {
465       Collection<Range<C>> positiveRanges;
473       final PeekingIterator<Range<C>> positiveItr = Iterators.peekingIterator(
484       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
488         protected Entry<Cut<C>, Range<C>> computeNext() {
493           Range<C> negativeRange;
495             Range<C> positiveRange = positiveItr.next();
496             negativeRange = Range.create(nextComplementRangeLowerBound, positiveRange.lowerBound);
499             negativeRange = Range.create(nextComplementRangeLowerBound, Cut.<C>aboveAll());
508     Iterator<Entry<Cut<C>, Range<C>>> descendingEntryIterator() {
522       final PeekingIterator<Range<C>> positiveItr =
538       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
542         protected Entry<Cut<C>, Range<C>> computeNext() {
546             Range<C> positiveRange = positiveItr.next();
547             Range<C> negativeRange =
548                 Range.create(positiveRange.upperBound, nextComplementRangeUpperBound);
554             Range<C> negativeRange =
555                 Range.create(Cut.<C>belowAll(), nextComplementRangeUpperBound);
571     public Range<C> get(Object key) {
577           Entry<Cut<C>, Range<C>> firstEntry = tailMap(cut, true).firstEntry();
600     public void add(Range<C> rangeToAdd) {
605     public void remove(Range<C> rangeToRemove) {
621       extends AbstractNavigableMap<Cut<C>, Range<C>> {
626     private final Range<Cut<C>> lowerBoundWindow;
632     private final Range<C> restriction;
634     private final NavigableMap<Cut<C>, Range<C>> rangesByLowerBound;
635     private final NavigableMap<Cut<C>, Range<C>> rangesByUpperBound;
637     private SubRangeSetRangesByLowerBound(Range<Cut<C>> lowerBoundWindow, Range<C> restriction,
638         NavigableMap<Cut<C>, Range<C>> rangesByLowerBound) {
645     private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> window) {
655     public NavigableMap<Cut<C>, Range<C>> subMap(
657       return subMap(Range.range(
662     public NavigableMap<Cut<C>, Range<C>> headMap(Cut<C> toKey, boolean inclusive) {
663       return subMap(Range.upTo(toKey, BoundType.forBoolean(inclusive)));
667     public NavigableMap<Cut<C>, Range<C>> tailMap(Cut<C> fromKey, boolean inclusive) {
668       return subMap(Range.downTo(fromKey, BoundType.forBoolean(inclusive)));
683     public Range<C> get(@Nullable Object key) {
693             Range<C> candidate = Maps.valueOrNull(rangesByLowerBound.floorEntry(cut));
698             Range<C> result = rangesByLowerBound.get(cut);
711     Iterator<Entry<Cut<C>, Range<C>>> entryIterator() {
715       final Iterator<Range<C>> completeRangeItr;
729       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
731         protected Entry<Cut<C>, Range<C>> computeNext() {
735           Range<C> nextRange = completeRangeItr.next();
747     Iterator<Entry<Cut<C>, Range<C>>> descendingEntryIterator() {
753       final Iterator<Range<C>> completeRangeItr = rangesByLowerBound.headMap(
757       return new AbstractIterator<Entry<Cut<C>, Range<C>>>() {
759         protected Entry<Cut<C>, Range<C>> computeNext() {
763           Range<C> nextRange = completeRangeItr.next();
784   public RangeSet<C> subRangeSet(Range<C> view) {
785     return view.equals(Range.<C>all()) ? this : new SubRangeSet(view);
789     private final Range<C> restriction;
791     SubRangeSet(Range<C> restriction) {
793           Range.<Cut<C>>all(), restriction, TreeRangeSet.this.rangesByLowerBound));
798     public boolean encloses(Range<C> range) {
800         Range<C> enclosing = TreeRangeSet.this.rangeEnclosing(range);
808     public Range<C> rangeContaining(C value) {
812       Range<C> result = TreeRangeSet.this.rangeContaining(value);
817     public void add(Range<C> rangeToAdd) {
824     public void remove(Range<C> rangeToRemove) {
841     public RangeSet<C> subRangeSet(Range<C> view) {