Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

com.google.common.collect
Class ForwardingNavigableMap<K,V>

java.lang.Object
  extended by com.google.common.collect.ForwardingObject
      extended by com.google.common.collect.ForwardingMap<K,V>
          extended by com.google.common.collect.ForwardingSortedMap<K,V>
              extended by com.google.common.collect.ForwardingNavigableMap<K,V>
All Implemented Interfaces:
java.util.Map<K,V>, java.util.NavigableMap<K,V>, java.util.SortedMap<K,V>
public abstract class ForwardingNavigableMap<K,V>
extends ForwardingSortedMap<K,V>
implements java.util.NavigableMap<K,V>

A navigable map which forwards all its method calls to another navigable map. Subclasses should override one or more methods to modify the behavior of the backing map as desired per the decorator pattern.

Warning: The methods of ForwardingNavigableMap forward indiscriminately to the methods of the delegate. For example, overriding ForwardingMap.put(K, V) alone will not change the behavior of ForwardingMap.putAll(java.util.Map), which can lead to unexpected behavior. In this case, you should override putAll as well, either providing your own implementation, or delegating to the provided standardPutAll method.

Each of the standard methods uses the map's comparator (or the natural ordering of the elements, if there is no comparator) to test element equality. As a result, if the comparator is not consistent with equals, some of the standard implementations may violate the Map contract.

The standard methods and the collection views they return are not guaranteed to be thread-safe, even when all of the methods that they depend on are thread-safe.

Since:
12.0

Nested Class Summary
protected  class ForwardingNavigableMap.StandardDescendingMap
          A sensible implementation of NavigableMap.descendingMap() in terms of the methods of this NavigableMap.
protected  class ForwardingNavigableMap.StandardNavigableKeySet
          A sensible implementation of NavigableMap.navigableKeySet() in terms of the methods of this NavigableMap.
 
Nested classes/interfaces inherited from class com.google.common.collect.ForwardingMap
ForwardingMap.StandardEntrySet, ForwardingMap.StandardKeySet, ForwardingMap.StandardValues
 
Nested classes/interfaces inherited from interface java.util.Map
java.util.Map.Entry<K,V>
 
Constructor Summary
protected ForwardingNavigableMap()
          Constructor for use by subclasses.
 
Method Summary
 java.util.Map.Entry<K,V> ceilingEntry(K key)
           
 K ceilingKey(K key)
           
protected abstract  java.util.NavigableMap<K,V> delegate()
          Returns the backing delegate instance that methods are forwarded to.
 java.util.NavigableSet<K> descendingKeySet()
           
 java.util.NavigableMap<K,V> descendingMap()
           
 java.util.Map.Entry<K,V> firstEntry()
           
 java.util.Map.Entry<K,V> floorEntry(K key)
           
 K floorKey(K key)
           
 java.util.NavigableMap<K,V> headMap(K toKey, boolean inclusive)
           
 java.util.Map.Entry<K,V> higherEntry(K key)
           
 K higherKey(K key)
           
 java.util.Map.Entry<K,V> lastEntry()
           
 java.util.Map.Entry<K,V> lowerEntry(K key)
           
 K lowerKey(K key)
           
 java.util.NavigableSet<K> navigableKeySet()
           
 java.util.Map.Entry<K,V> pollFirstEntry()
           
 java.util.Map.Entry<K,V> pollLastEntry()
           
protected  java.util.Map.Entry<K,V> standardCeilingEntry(K key)
          A sensible definition of ceilingEntry(K) in terms of the firstEntry() of tailMap(Object, boolean).
protected  K standardCeilingKey(K key)
          A sensible definition of ceilingKey(K) in terms of ceilingEntry.
protected  java.util.NavigableSet<K> standardDescendingKeySet()
          A sensible definition of descendingKeySet() as the navigableKeySet of descendingMap().
protected  java.util.Map.Entry<K,V> standardFirstEntry()
          A sensible definition of firstEntry() in terms of the iterator() of ForwardingMap.entrySet().
protected  K standardFirstKey()
          A sensible definition of ForwardingSortedMap.firstKey() in terms of firstEntry.
protected  java.util.Map.Entry<K,V> standardFloorEntry(K key)
          A sensible definition of floorEntry(K) in terms of the lastEntry() of headMap(Object, boolean).
protected  K standardFloorKey(K key)
          A sensible definition of floorKey(K) in terms of floorEntry.
protected  java.util.SortedMap<K,V> standardHeadMap(K toKey)
          A sensible definition of ForwardingSortedMap.headMap(Object) in terms of headMap(Object, boolean).
protected  java.util.Map.Entry<K,V> standardHigherEntry(K key)
          A sensible definition of higherEntry(K) in terms of the firstEntry() of tailMap(Object, boolean).
protected  K standardHigherKey(K key)
          A sensible definition of higherKey(K) in terms of higherEntry.
protected  java.util.Map.Entry<K,V> standardLastEntry()
          A sensible definition of lastEntry() in terms of the iterator() of the ForwardingMap.entrySet() of descendingMap().
protected  K standardLastKey()
          A sensible definition of ForwardingSortedMap.lastKey() in terms of lastEntry.
protected  java.util.Map.Entry<K,V> standardLowerEntry(K key)
          A sensible definition of lowerEntry(K) in terms of the lastEntry() of headMap(Object, boolean).
protected  K standardLowerKey(K key)
          A sensible definition of lowerKey(K) in terms of lowerEntry.
protected  java.util.Map.Entry<K,V> standardPollFirstEntry()
          A sensible definition of pollFirstEntry() in terms of the iterator of entrySet.
protected  java.util.Map.Entry<K,V> standardPollLastEntry()
          A sensible definition of pollFirstEntry() in terms of the iterator of the entrySet of descendingMap.
protected  java.util.SortedMap<K,V> standardSubMap(K fromKey, K toKey)
          A sensible definition of ForwardingSortedMap.subMap(Object, Object) in terms of subMap(Object, boolean, Object, boolean).
protected  java.util.SortedMap<K,V> standardTailMap(K fromKey)
          A sensible definition of ForwardingSortedMap.tailMap(Object) in terms of tailMap(Object, boolean).
 java.util.NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
           
 java.util.NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
           
 
Methods inherited from class com.google.common.collect.ForwardingSortedMap
comparator, firstKey, headMap, lastKey, standardContainsKey, standardRemove, subMap, tailMap
 
Methods inherited from class com.google.common.collect.ForwardingMap
clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, standardClear, standardContainsValue, standardEquals, standardHashCode, standardIsEmpty, standardPutAll, standardToString, values
 
Methods inherited from class com.google.common.collect.ForwardingObject
toString
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface java.util.NavigableMap
headMap, subMap, tailMap
 
Methods inherited from interface java.util.SortedMap
comparator, entrySet, firstKey, keySet, lastKey, values
 
Methods inherited from interface java.util.Map
clear, containsKey, containsValue, equals, get, hashCode, isEmpty, put, putAll, remove, size
 

Constructor Detail

ForwardingNavigableMap

protected ForwardingNavigableMap()
Constructor for use by subclasses.

Method Detail

delegate

protected abstract java.util.NavigableMap<K,V> delegate()
Description copied from class: ForwardingObject
Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as ForwardingSet.delegate(). Concrete subclasses override this method to supply the instance being decorated.

Specified by:
delegate in class ForwardingSortedMap<K,V>

lowerEntry

public java.util.Map.Entry<K,V> lowerEntry(K key)
Specified by:
lowerEntry in interface java.util.NavigableMap<K,V>

standardLowerEntry

protected java.util.Map.Entry<K,V> standardLowerEntry(K key)
A sensible definition of lowerEntry(K) in terms of the lastEntry() of headMap(Object, boolean). If you override headMap, you may wish to override lowerEntry to forward to this implementation.

lowerKey

public K lowerKey(K key)
Specified by:
lowerKey in interface java.util.NavigableMap<K,V>

standardLowerKey

protected K standardLowerKey(K key)
A sensible definition of lowerKey(K) in terms of lowerEntry. If you override lowerEntry(K), you may wish to override lowerKey to forward to this implementation.

floorEntry

public java.util.Map.Entry<K,V> floorEntry(K key)
Specified by:
floorEntry in interface java.util.NavigableMap<K,V>

standardFloorEntry

protected java.util.Map.Entry<K,V> standardFloorEntry(K key)
A sensible definition of floorEntry(K) in terms of the lastEntry() of headMap(Object, boolean). If you override headMap, you may wish to override floorEntry to forward to this implementation.

floorKey

public K floorKey(K key)
Specified by:
floorKey in interface java.util.NavigableMap<K,V>

standardFloorKey

protected K standardFloorKey(K key)
A sensible definition of floorKey(K) in terms of floorEntry. If you override floorEntry, you may wish to override floorKey to forward to this implementation.

ceilingEntry

public java.util.Map.Entry<K,V> ceilingEntry(K key)
Specified by:
ceilingEntry in interface java.util.NavigableMap<K,V>

standardCeilingEntry

protected java.util.Map.Entry<K,V> standardCeilingEntry(K key)
A sensible definition of ceilingEntry(K) in terms of the firstEntry() of tailMap(Object, boolean). If you override tailMap, you may wish to override ceilingEntry to forward to this implementation.

ceilingKey

public K ceilingKey(K key)
Specified by:
ceilingKey in interface java.util.NavigableMap<K,V>

standardCeilingKey

protected K standardCeilingKey(K key)
A sensible definition of ceilingKey(K) in terms of ceilingEntry. If you override ceilingEntry, you may wish to override ceilingKey to forward to this implementation.

higherEntry

public java.util.Map.Entry<K,V> higherEntry(K key)
Specified by:
higherEntry in interface java.util.NavigableMap<K,V>

standardHigherEntry

protected java.util.Map.Entry<K,V> standardHigherEntry(K key)
A sensible definition of higherEntry(K) in terms of the firstEntry() of tailMap(Object, boolean). If you override tailMap, you may wish to override higherEntry to forward to this implementation.

higherKey

public K higherKey(K key)
Specified by:
higherKey in interface java.util.NavigableMap<K,V>

standardHigherKey

protected K standardHigherKey(K key)
A sensible definition of higherKey(K) in terms of higherEntry. If you override higherEntry, you may wish to override higherKey to forward to this implementation.

firstEntry

public java.util.Map.Entry<K,V> firstEntry()
Specified by:
firstEntry in interface java.util.NavigableMap<K,V>

standardFirstEntry

protected java.util.Map.Entry<K,V> standardFirstEntry()
A sensible definition of firstEntry() in terms of the iterator() of ForwardingMap.entrySet(). If you override entrySet, you may wish to override firstEntry to forward to this implementation.

standardFirstKey

protected K standardFirstKey()
A sensible definition of ForwardingSortedMap.firstKey() in terms of firstEntry. If you override firstEntry, you may wish to override firstKey to forward to this implementation.

lastEntry

public java.util.Map.Entry<K,V> lastEntry()
Specified by:
lastEntry in interface java.util.NavigableMap<K,V>

standardLastEntry

protected java.util.Map.Entry<K,V> standardLastEntry()
A sensible definition of lastEntry() in terms of the iterator() of the ForwardingMap.entrySet() of descendingMap(). If you override descendingMap, you may wish to override lastEntry to forward to this implementation.

standardLastKey

protected K standardLastKey()
A sensible definition of ForwardingSortedMap.lastKey() in terms of lastEntry. If you override lastEntry, you may wish to override lastKey to forward to this implementation.

pollFirstEntry

public java.util.Map.Entry<K,V> pollFirstEntry()
Specified by:
pollFirstEntry in interface java.util.NavigableMap<K,V>

standardPollFirstEntry

protected java.util.Map.Entry<K,V> standardPollFirstEntry()
A sensible definition of pollFirstEntry() in terms of the iterator of entrySet. If you override entrySet, you may wish to override pollFirstEntry to forward to this implementation.

pollLastEntry

public java.util.Map.Entry<K,V> pollLastEntry()
Specified by:
pollLastEntry in interface java.util.NavigableMap<K,V>

standardPollLastEntry

protected java.util.Map.Entry<K,V> standardPollLastEntry()
A sensible definition of pollFirstEntry() in terms of the iterator of the entrySet of descendingMap. If you override descendingMap, you may wish to override pollFirstEntry to forward to this implementation.

descendingMap

public java.util.NavigableMap<K,V> descendingMap()
Specified by:
descendingMap in interface java.util.NavigableMap<K,V>

navigableKeySet

public java.util.NavigableSet<K> navigableKeySet()
Specified by:
navigableKeySet in interface java.util.NavigableMap<K,V>

descendingKeySet

public java.util.NavigableSet<K> descendingKeySet()
Specified by:
descendingKeySet in interface java.util.NavigableMap<K,V>

standardDescendingKeySet

@Beta
protected java.util.NavigableSet<K> standardDescendingKeySet()
A sensible definition of descendingKeySet() as the navigableKeySet of descendingMap(). (The ForwardingNavigableMap.StandardDescendingMap implementation implements navigableKeySet on its own, so as not to cause an infinite loop.) If you override descendingMap, you may wish to override descendingKeySet to forward to this implementation.

standardSubMap

protected java.util.SortedMap<K,V> standardSubMap(K fromKey,
                                                  K toKey)
A sensible definition of ForwardingSortedMap.subMap(Object, Object) in terms of subMap(Object, boolean, Object, boolean). If you override subMap(K, boolean, K, boolean), you may wish to override subMap to forward to this implementation.

Overrides:
standardSubMap in class ForwardingSortedMap<K,V>

subMap

public java.util.NavigableMap<K,V> subMap(K fromKey,
                                          boolean fromInclusive,
                                          K toKey,
                                          boolean toInclusive)
Specified by:
subMap in interface java.util.NavigableMap<K,V>

headMap

public java.util.NavigableMap<K,V> headMap(K toKey,
                                           boolean inclusive)
Specified by:
headMap in interface java.util.NavigableMap<K,V>

tailMap

public java.util.NavigableMap<K,V> tailMap(K fromKey,
                                           boolean inclusive)
Specified by:
tailMap in interface java.util.NavigableMap<K,V>

standardHeadMap

protected java.util.SortedMap<K,V> standardHeadMap(K toKey)
A sensible definition of ForwardingSortedMap.headMap(Object) in terms of headMap(Object, boolean). If you override headMap(K, boolean), you may wish to override headMap to forward to this implementation.

standardTailMap

protected java.util.SortedMap<K,V> standardTailMap(K fromKey)
A sensible definition of ForwardingSortedMap.tailMap(Object) in terms of tailMap(Object, boolean). If you override tailMap(K, boolean), you may wish to override tailMap to forward to this implementation.

Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD