com.google.common.collect

Class ForwardingNavigableMap<K,V>

java.lang.Object

com.google.common.collect.ForwardingObject

com.google.common.collect.ForwardingMap<K,V>

com.google.common.collect.ForwardingSortedMap<K,V>

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

All Implemented Interfaces:

Map<K,V>, NavigableMap<K,V>, SortedMap<K,V>

@GwtIncompatible
public abstract class ForwardingNavigableMap<K,V>
extends ForwardingSortedMap<K,V>
implements 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<? extends K, ? extends V>), 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.

default method warning: This class does not forward calls to default methods. Instead, it inherits their default implementations. When those implementations invoke methods, they invoke methods on the ForwardingNavigableMap.

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

Author:

Louis Wasserman

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
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.ForwardingSortedMap

ForwardingSortedMap.StandardKeySet

Nested classes/interfaces inherited from class com.google.common.collect.ForwardingMap

ForwardingMap.StandardEntrySet, ForwardingMap.StandardValues

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ForwardingNavigableMap() Constructor for use by subclasses.

Method Summary

Modifier and Type	Method and Description
Map.Entry<K,V>	ceilingEntry(K key) Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.
K	ceilingKey(K key) Returns the least key greater than or equal to the given key, or null if there is no such key.
protected abstract NavigableMap<K,V>	delegate() Returns the backing delegate instance that methods are forwarded to.
NavigableSet<K>	descendingKeySet() Returns a reverse order NavigableSet view of the keys contained in this map.
NavigableMap<K,V>	descendingMap() Returns a reverse order view of the mappings contained in this map.
Map.Entry<K,V>	firstEntry() Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
Map.Entry<K,V>	floorEntry(K key) Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
K	floorKey(K key) Returns the greatest key less than or equal to the given key, or null if there is no such key.
NavigableMap<K,V>	headMap(K toKey, boolean inclusive) Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey.
Map.Entry<K,V>	higherEntry(K key) Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
K	higherKey(K key) Returns the least key strictly greater than the given key, or null if there is no such key.
Map.Entry<K,V>	lastEntry() Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
Map.Entry<K,V>	lowerEntry(K key) Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
K	lowerKey(K key) Returns the greatest key strictly less than the given key, or null if there is no such key.
NavigableSet<K>	navigableKeySet() Returns a NavigableSet view of the keys contained in this map.
Map.Entry<K,V>	pollFirstEntry() Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
Map.Entry<K,V>	pollLastEntry() Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
protected 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 NavigableSet<K>	standardDescendingKeySet() A sensible definition of descendingKeySet() as the navigableKeySet of descendingMap().
protected 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 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 SortedMap<K,V>	standardHeadMap(K toKey) A sensible definition of ForwardingSortedMap.headMap(Object) in terms of headMap(Object, boolean).
protected 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 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 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 Map.Entry<K,V>	standardPollFirstEntry() A sensible definition of pollFirstEntry() in terms of the iterator of entrySet.
protected Map.Entry<K,V>	standardPollLastEntry() A sensible definition of pollFirstEntry() in terms of the iterator of the entrySet of descendingMap.
protected 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 SortedMap<K,V>	standardTailMap(K fromKey) A sensible definition of ForwardingSortedMap.tailMap(Object) in terms of tailMap(Object, boolean).
NavigableMap<K,V>	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) Returns a view of the portion of this map whose keys range from fromKey to toKey.
NavigableMap<K,V>	tailMap(K fromKey, boolean inclusive) Returns a view of the portion of this map whose keys are greater than (or equal to, if inclusive is true) fromKey.

Methods inherited from class com.google.common.collect.ForwardingSortedMap

comparator, firstKey, headMap, lastKey, standardContainsKey, 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, standardRemove, 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, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, equals, forEach, get, getOrDefault, hashCode, isEmpty, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size

Constructor Detail

ForwardingNavigableMap

protected ForwardingNavigableMap()

Constructor for use by subclasses.

Method Detail

delegate

protected abstract 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 Map.Entry<K,V> lowerEntry(K key)

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.

Specified by:

lowerEntry in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

an entry with the greatest key less than key, or null if there is no such key

standardLowerEntry

protected 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)

Description copied from interface: java.util.NavigableMap

Returns the greatest key strictly less than the given key, or null if there is no such key.

Specified by:

lowerKey in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

the greatest key less than key, or null if there is no such key

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 Map.Entry<K,V> floorEntry(K key)

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.

Specified by:

floorEntry in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

an entry with the greatest key less than or equal to key, or null if there is no such key

standardFloorEntry

protected 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)

Description copied from interface: java.util.NavigableMap

Returns the greatest key less than or equal to the given key, or null if there is no such key.

Specified by:

floorKey in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

the greatest key less than or equal to key, or null if there is no such key

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 Map.Entry<K,V> ceilingEntry(K key)

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.

Specified by:

ceilingEntry in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

an entry with the least key greater than or equal to key, or null if there is no such key

standardCeilingEntry

protected 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)

Description copied from interface: java.util.NavigableMap

Returns the least key greater than or equal to the given key, or null if there is no such key.

Specified by:

ceilingKey in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

the least key greater than or equal to key, or null if there is no such key

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 Map.Entry<K,V> higherEntry(K key)

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.

Specified by:

higherEntry in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

an entry with the least key greater than key, or null if there is no such key

standardHigherEntry

protected 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)

Description copied from interface: java.util.NavigableMap

Returns the least key strictly greater than the given key, or null if there is no such key.

Specified by:

higherKey in interface NavigableMap<K,V>

Parameters:

key - the key

Returns:

the least key greater than key, or null if there is no such key

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 Map.Entry<K,V> firstEntry()

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the least key in this map, or null if the map is empty.

Specified by:

firstEntry in interface NavigableMap<K,V>

Returns:

an entry with the least key, or null if this map is empty

standardFirstEntry

protected 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 Map.Entry<K,V> lastEntry()

Description copied from interface: java.util.NavigableMap

Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

Specified by:

lastEntry in interface NavigableMap<K,V>

Returns:

an entry with the greatest key, or null if this map is empty

standardLastEntry

protected 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 Map.Entry<K,V> pollFirstEntry()

Description copied from interface: java.util.NavigableMap

Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.

Specified by:

pollFirstEntry in interface NavigableMap<K,V>

Returns:

the removed first entry of this map, or null if this map is empty

standardPollFirstEntry

protected 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 Map.Entry<K,V> pollLastEntry()

Description copied from interface: java.util.NavigableMap

Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

Specified by:

pollLastEntry in interface NavigableMap<K,V>

Returns:

the removed last entry of this map, or null if this map is empty

standardPollLastEntry

protected 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 NavigableMap<K,V> descendingMap()

Description copied from interface: java.util.NavigableMap

Returns a reverse order view of the mappings contained in this map. The descending map is backed by this map, so changes to the map are reflected in the descending map, and vice-versa. If either map is modified while an iteration over a collection view of either map is in progress (except through the iterator's own remove operation), the results of the iteration are undefined.

The returned map has an ordering equivalent to Collections.reverseOrder(comparator()). The expression m.descendingMap().descendingMap() returns a view of m essentially equivalent to m.

Specified by:

descendingMap in interface NavigableMap<K,V>

Returns:

a reverse order view of this map

navigableKeySet

public NavigableSet<K> navigableKeySet()

Description copied from interface: java.util.NavigableMap

Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Specified by:

navigableKeySet in interface NavigableMap<K,V>

Returns:

a navigable set view of the keys in this map

descendingKeySet

public NavigableSet<K> descendingKeySet()

Description copied from interface: java.util.NavigableMap

Returns a reverse order NavigableSet view of the keys contained in this map. The set's iterator returns the keys in descending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

Specified by:

descendingKeySet in interface NavigableMap<K,V>

Returns:

a reverse order navigable set view of the keys in this map

standardDescendingKeySet

@Beta
protected 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 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 NavigableMap<K,V> subMap(K fromKey,
                                boolean fromInclusive,
                                K toKey,
                                boolean toInclusive)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys range from fromKey to toKey. If fromKey and toKey are equal, the returned map is empty unless fromInclusive and toInclusive are both true. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

The returned map will throw an IllegalArgumentException on an attempt to insert a key outside of its range, or to construct a submap either of whose endpoints lie outside its range.

Specified by:

subMap in interface NavigableMap<K,V>

Parameters:

fromKey - low endpoint of the keys in the returned map

fromInclusive - true if the low endpoint is to be included in the returned view

toKey - high endpoint of the keys in the returned map

toInclusive - true if the high endpoint is to be included in the returned view

Returns:

a view of the portion of this map whose keys range from fromKey to toKey

headMap

public NavigableMap<K,V> headMap(K toKey,
                                 boolean inclusive)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

The returned map will throw an IllegalArgumentException on an attempt to insert a key outside its range.

Specified by:

headMap in interface NavigableMap<K,V>

Parameters:

toKey - high endpoint of the keys in the returned map

inclusive - true if the high endpoint is to be included in the returned view

Returns:

a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey

tailMap

public NavigableMap<K,V> tailMap(K fromKey,
                                 boolean inclusive)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys are greater than (or equal to, if inclusive is true) fromKey. The returned map is backed by this map, so changes in the returned map are reflected in this map, and vice-versa. The returned map supports all optional map operations that this map supports.

The returned map will throw an IllegalArgumentException on an attempt to insert a key outside its range.

Specified by:

tailMap in interface NavigableMap<K,V>

Parameters:

fromKey - low endpoint of the keys in the returned map

inclusive - true if the low endpoint is to be included in the returned view

Returns:

a view of the portion of this map whose keys are greater than (or equal to, if inclusive is true) fromKey

standardHeadMap

protected 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 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.