inet.ipaddr.format.util

Class AddressTrieMap<K extends Address,V>

java.lang.Object

java.util.AbstractMap<K,V>

inet.ipaddr.format.util.AddressTrieMap<K,V>

Type Parameters:

K - the address type

V - the type of the mapped values

All Implemented Interfaces:

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

public class AddressTrieMap<K extends Address,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable

Wraps a AssociativeAddressTrie to view it as a Java Collections Framework map, implementing the Map, SortedMap, and NavigableMap interfaces.

Like TreeMap, this map is backed by a binary tree and implements the same interfaces that TreeMap does. But there are some significant differences between the two binary tree implementations.

A trie is naturally balanced and can only reach a depth corresponding to the number of bits in the keys, which is 32 for IPv4 and 128 for IPv6 tries. The TreeMap is balanced using red-black balancing.

The AssociativeAddressTrie allows you to modify the map entries using Map.Entry.setValue(Object), while TreeMap does not. The entries provided by the TreeMap are copies of the original nodes, so that the original nodes can be re-purposed. The nodes are not exposed.

In the AssociativeAddressTrie nodes are not re-purposed, and in fact they are also exposed. This enables navigation through the nodes. The node hierarchy has a special meaning, there is only one hierarchy for any given set of addresses, since it is determined by prefix block subnet containment. The hierarchy enables certain address-specific containment-based operations, such as subnet deletion or containment checks.

In the trie map, when doing lookups and some other operations, only parts of the address keys are examined at each node in the binary tree search, rather than comparisons of the whole key, as with TreeMap. The trie map supports only the one comparison representing subnet containment, which is based on bit values and prefix length. The TreeMap is a general-purpose map supporting any natural ordering or Comparator.

With the trie map, only addresses that are either individual address or prefix block subnets of the same type and version can be added to the trie, see AddressTrie.AddressComparator for a comparator for the ordering.

Should you wish to store, in a map, address instances that are not individual address or prefix block subnets, you can use TreeMap or any other Java collections framework map to store addresses of any type, or addresses of different versions or types in the same map, since all address items in this library are comparable with a natural ordering. There are additional orderings provided by this library as well, see AddressComparator.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AddressTrieMap.EntrySet<K extends Address,V>

Nested classes/interfaces inherited from class java.util.AbstractMap

AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

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

Map.Entry<K,V>

Constructor Summary

Constructors

Constructor and Description
AddressTrieMap(AssociativeAddressTrie<K,V> trie)
AddressTrieMap(AssociativeAddressTrie<K,V> trie, Map<? extends K,? extends V> map)

Method Summary

Modifier and Type	Method and Description
AssociativeAddressTrie<K,V>	asTrie() Return a trie representing this map.
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.
void	clear() Removes all of the mappings from this map (optional operation).
AddressTrieMap<K,V>	clone() Clones the map along with the backing trie.
Comparator<K>	comparator() Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
V	computeIfAbsent(K key, Function<? super K,? extends V> remappingFunction) If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
boolean	containsKey(Object key) Returns true if this map contains a mapping for the specified key.
boolean	containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
AddressTrieSet<K>	descendingKeySet() Returns a reverse order NavigableSet view of the keys contained in this map.
AddressTrieMap<K,V>	descendingMap() Returns a reverse order view of the mappings contained in this map.
AddressTrieMap.EntrySet<K,V>	entrySet() Returns a Set view of the mappings contained in this map.
boolean	equals(Object o) Compares the specified object with this map for equality.
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.
K	firstKey() Returns the first (lowest) key currently in this map.
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.
void	forEach(BiConsumer<? super K,? super V> action) Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
V	get(Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
V	getOrDefault(Object key, V defaultValue) Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
AddressTrieSet.Range<K>	getRange() Returns the range if this map has a restricted range, see hasRestrictedRange().
int	hashCode() Returns the hash code value for this map.
boolean	hasRestrictedRange() Returns whether this map is the result of a call to headMap(Address), tailMap(Address), subMap(Address, Address) or any of the other methods with the same names.
AddressTrieMap<K,V>	headMap(K toKey) Returns a view of the portion of this map whose keys are strictly less than toKey.
AddressTrieMap<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.
boolean	isEmpty() Returns true if this map contains no key-value mappings.
boolean	keyContains(K addr) Returns true if a subnet or address key in the map contains the given subnet or address.
AddressTrieSet<K>	keySet() Returns a Set view of the keys contained in this map.
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.
K	lastKey() Returns the last (highest) key currently in this map.
Map.Entry<K,V>	longestPrefixMatchEntry(K addr) Returns the map entry corresponding to the key with the longest prefix match with the given address.
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.
V	merge(K key, V suppliedValue, BiFunction<? super V,? super V,? extends V> remappingFunction) If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
AddressTrieSet<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.
V	put(K key, V value) Maps the given single address or prefix block subnet to the given value in the map.
V	putIfAbsent(K key, V value) If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value.
V	remove(Object key) Removes the mapping for a key from this map if it is present (optional operation).
boolean	remove(Object key, Object value) Removes the entry for the specified key only if it is currently mapped to the specified value.
V	replace(K key, V value) Replaces the entry for the specified key only if it is currently mapped to some value.
boolean	replace(K key, V oldValue, V newValue) Replaces the entry for the specified key only if currently mapped to the specified value.
void	replaceAll(BiFunction<? super K,? super V,? extends V> function) Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
int	size() Returns the number of mappings in this map.
AddressTrieMap<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.
AddressTrieMap<K,V>	subMap(K fromKey, K toKey) Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive.
AddressTrieMap<K,V>	subMapFromKeysContainedBy(K addr) Returns a sub-map consisting of the mappings in the map with address keys contained by the given address The sub-map will have a restricted range matching the range of the given subnet or address.
AddressTrieMap<K,V>	subMapFromKeysContaining(K addr) Returns a sub-map consisting of the mappings in the map with address keys that contain the given address.
AddressTrieMap<K,V>	tailMap(K fromKey) Returns a view of the portion of this map whose keys are greater than or equal to fromKey.
AddressTrieMap<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.
String	toTrieString()

Methods inherited from class java.util.AbstractMap

putAll, toString, values

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.SortedMap

values

Methods inherited from interface java.util.Map

putAll

Constructor Detail

AddressTrieMap

public AddressTrieMap(AssociativeAddressTrie<K,V> trie)

AddressTrieMap

public AddressTrieMap(AssociativeAddressTrie<K,V> trie,
                      Map<? extends K,? extends V> map)

Method Detail

descendingMap

public AddressTrieMap<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 extends Address,V>

Returns:

a reverse order view of this map

descendingKeySet

public AddressTrieSet<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 extends Address,V>

Returns:

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

asTrie

public AssociativeAddressTrie<K,V> asTrie()

Return a trie representing this map.

If this map has a restricted range, see hasRestrictedRange(), this generates a new trie corresponding to the map with only the nodes pertaining to the restricted range sub-map. Otherwise this returns the original backing trie for this map.

When a new trie is generated, the original backing trie for this map remains the same, it is not changed to the new trie.

The returned trie will always have the same natural trie ordering, even if this map has the reverse ordering.

hasRestrictedRange

public boolean hasRestrictedRange()

Returns whether this map is the result of a call to headMap(Address), tailMap(Address), subMap(Address, Address) or any of the other methods with the same names.

Returns:

getRange

public AddressTrieSet.Range<K> getRange()

Returns the range if this map has a restricted range, see hasRestrictedRange(). Otherwise returns null.

Returns:

keySet

public AddressTrieSet<K> keySet()

Description copied from class: java.util.AbstractMap

Returns a Set view of the keys contained in this map. 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:

keySet in interface Map<K extends Address,V>

Specified by:

keySet in interface SortedMap<K extends Address,V>

Overrides:

keySet in class AbstractMap<K extends Address,V>

Returns:

a set view of the keys contained in this map

navigableKeySet

public AddressTrieSet<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 extends Address,V>

Returns:

a navigable set view of the keys in this map

entrySet

public AddressTrieMap.EntrySet<K,V> entrySet()

Description copied from interface: java.util.Map

Returns a Set view of the mappings contained in this map. 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, or through the setValue operation on a map entry returned by the iterator) 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:

entrySet in interface Map<K extends Address,V>

Specified by:

entrySet in interface SortedMap<K extends Address,V>

Specified by:

entrySet in class AbstractMap<K extends Address,V>

Returns:

a set view of the mappings contained in this map

merge

public V merge(K key,
               V suppliedValue,
               BiFunction<? super V,? super V,? extends V> remappingFunction)

Description copied from interface: java.util.Map

If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value. Otherwise, replaces the associated value with the results of the given remapping function, or removes if the result is null. This method may be of use when combining multiple mapped values for a key. For example, to either create or append a String msg to a value mapping:

 
 map.merge(key, msg, String::concat)
 

If the function returns null the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

Specified by:

merge in interface Map<K extends Address,V>

Parameters:

key - key with which the resulting value is to be associated

suppliedValue - the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key

remappingFunction - the function to recompute a value if present

Returns:

the new value associated with the specified key, or null if no value is associated with the key

compute

public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)

Description copied from interface: java.util.Map

Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping). For example, to either create or append a String msg to a value mapping:

 
 map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))

(Method merge() is often simpler to use for such purposes.)

If the function returns null, the mapping is removed (or remains absent if initially absent). If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

Specified by:

compute in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is to be associated

remappingFunction - the function to compute a value

Returns:

the new value associated with the specified key, or null if none

computeIfAbsent

public V computeIfAbsent(K key,
                         Function<? super K,? extends V> remappingFunction)

Description copied from interface: java.util.Map

If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.

If the function returns null no mapping is recorded. If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded. The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in:

 
 map.computeIfAbsent(key, k -> new Value(f(k)));
 

Or to implement a multi-value map, Map<K,Collection<V>>, supporting multiple values per key:

 
 map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
 

Specified by:

computeIfAbsent in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is to be associated

remappingFunction - the function to compute a value

Returns:

the current (existing or computed) value associated with the specified key, or null if the computed value is null

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Description copied from interface: java.util.Map

If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value.

Specified by:

putIfAbsent in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is to be associated

value - value to be associated with the specified key

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

computeIfPresent

public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)

Description copied from interface: java.util.Map

If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.

If the function returns null, the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

Specified by:

computeIfPresent in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is to be associated

remappingFunction - the function to compute a value

Returns:

the new value associated with the specified key, or null if none

containsKey

public boolean containsKey(Object key)

Description copied from class: java.util.AbstractMap

Returns true if this map contains a mapping for the specified key. More formally, returns true if and only if this map contains a mapping for a key k such that (key==null ? k==null : key.equals(k)). (There can be at most one such mapping.)

Specified by:

containsKey in interface Map<K extends Address,V>

Overrides:

containsKey in class AbstractMap<K extends Address,V>

Parameters:

key - key whose presence in this map is to be tested

Returns:

true if this map contains a mapping for the specified key

containsValue

public boolean containsValue(Object value)

Description copied from class: java.util.AbstractMap

Returns true if this map maps one or more keys to the specified value. More formally, returns true if and only if this map contains at least one mapping to a value v such that (value==null ? v==null : value.equals(v)). This operation will probably require time linear in the map size for most implementations of the Map interface.

Specified by:

containsValue in interface Map<K extends Address,V>

Overrides:

containsValue in class AbstractMap<K extends Address,V>

Parameters:

value - value whose presence in this map is to be tested

Returns:

true if this map maps one or more keys to the specified value

get

public V get(Object key)

Description copied from class: java.util.AbstractMap

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key k to a value v such that (key==null ? k==null : key.equals(k)), then this method returns v; otherwise it returns null. (There can be at most one such mapping.)

If this map permits null values, then a return value of null does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to null. The containsKey operation may be used to distinguish these two cases.

Specified by:

get in interface Map<K extends Address,V>

Overrides:

get in class AbstractMap<K extends Address,V>

Parameters:

key - the key whose associated value is to be returned

Returns:

the value to which the specified key is mapped, or null if this map contains no mapping for the key

put

public V put(K key,
             V value)

Maps the given single address or prefix block subnet to the given value in the map.

If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.

See AssociativeAddressTrie

Specified by:

put in interface Map<K extends Address,V>

Overrides:

put in class AbstractMap<K extends Address,V>

Parameters:

key - key with which the specified value is to be associated

value - value to be associated with the specified key

Returns:

the previous value associated with key, or null if there was no mapping for key. (A null return can also indicate that the map previously associated null with key, if the implementation supports null values.)

remove

public V remove(Object key)

Description copied from class: java.util.AbstractMap

Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The map can contain at most one such mapping.)

Returns the value to which this map previously associated the key, or null if the map contained no mapping for the key.

If this map permits null values, then a return value of null does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to null.

The map will not contain a mapping for the specified key once the call returns.

Specified by:

remove in interface Map<K extends Address,V>

Overrides:

remove in class AbstractMap<K extends Address,V>

Parameters:

key - key whose mapping is to be removed from the map

Returns:

the previous value associated with key, or null if there was no mapping for key.

getOrDefault

public V getOrDefault(Object key,
                      V defaultValue)

Description copied from interface: java.util.Map

Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

Specified by:

getOrDefault in interface Map<K extends Address,V>

Parameters:

key - the key whose associated value is to be returned

defaultValue - the default mapping of the key

Returns:

the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key

forEach

public void forEach(BiConsumer<? super K,? super V> action)

Description copied from interface: java.util.Map

Performs the given action for each entry in this map until all entries have been processed or the action throws an exception. Unless otherwise specified by the implementing class, actions are performed in the order of entry set iteration (if an iteration order is specified.) Exceptions thrown by the action are relayed to the caller.

Specified by:

forEach in interface Map<K extends Address,V>

Parameters:

action - The action to be performed for each entry

replaceAll

public void replaceAll(BiFunction<? super K,? super V,? extends V> function)

Description copied from interface: java.util.Map

Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception. Exceptions thrown by the function are relayed to the caller.

Specified by:

replaceAll in interface Map<K extends Address,V>

Parameters:

function - the function to apply to each entry

remove

public boolean remove(Object key,
                      Object value)

Description copied from interface: java.util.Map

Removes the entry for the specified key only if it is currently mapped to the specified value.

Specified by:

remove in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is associated

value - value expected to be associated with the specified key

Returns:

true if the value was removed

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Description copied from interface: java.util.Map

Replaces the entry for the specified key only if currently mapped to the specified value.

Specified by:

replace in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is associated

oldValue - value expected to be associated with the specified key

newValue - value to be associated with the specified key

Returns:

true if the value was replaced

replace

public V replace(K key,
                 V value)

Description copied from interface: java.util.Map

Replaces the entry for the specified key only if it is currently mapped to some value.

Specified by:

replace in interface Map<K extends Address,V>

Parameters:

key - key with which the specified value is associated

value - value to be associated with the specified key

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

size

public int size()

Returns the number of mappings in this map. This is a constant time operation, unless the map has a restricted range, see hasRestrictedRange(), in which case it is a linear time operation proportional to the number of mappings.

Specified by:

size in interface Map<K extends Address,V>

Overrides:

size in class AbstractMap<K extends Address,V>

Returns:

the number of elements in this map

isEmpty

public boolean isEmpty()

Description copied from class: java.util.AbstractMap

Returns true if this map contains no key-value mappings.

Specified by:

isEmpty in interface Map<K extends Address,V>

Overrides:

isEmpty in class AbstractMap<K extends Address,V>

Returns:

true if this map contains no key-value mappings

clear

public void clear()

Description copied from class: java.util.AbstractMap

Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

Specified by:

clear in interface Map<K extends Address,V>

Overrides:

clear in class AbstractMap<K extends Address,V>

hashCode

public int hashCode()

Description copied from class: java.util.AbstractMap

Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's entrySet() view. This ensures that m1.equals(m2) implies that m1.hashCode()==m2.hashCode() for any two maps m1 and m2, as required by the general contract of Object.hashCode().

Specified by:

hashCode in interface Map<K extends Address,V>

Overrides:

hashCode in class AbstractMap<K extends Address,V>

Returns:

the hash code value for this map

See Also:

Map.Entry.hashCode(), Object.equals(Object), Set.equals(Object)

subMap

public AddressTrieMap<K,V> subMap(K fromKey,
                                  K toKey)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive. (If fromKey and toKey are equal, the returned map is empty.) 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.

Equivalent to subMap(fromKey, true, toKey, false).

Specified by:

subMap in interface NavigableMap<K extends Address,V>

Specified by:

subMap in interface SortedMap<K extends Address,V>

Parameters:

fromKey - low endpoint (inclusive) of the keys in the returned map

toKey - high endpoint (exclusive) of the keys in the returned map

Returns:

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

subMap

public AddressTrieMap<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 extends Address,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 AddressTrieMap<K,V> headMap(K toKey)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys are strictly less than 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.

Equivalent to headMap(toKey, false).

Specified by:

headMap in interface NavigableMap<K extends Address,V>

Specified by:

headMap in interface SortedMap<K extends Address,V>

Parameters:

toKey - high endpoint (exclusive) of the keys in the returned map

Returns:

a view of the portion of this map whose keys are strictly less than toKey

headMap

public AddressTrieMap<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 extends Address,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 AddressTrieMap<K,V> tailMap(K fromKey)

Description copied from interface: java.util.NavigableMap

Returns a view of the portion of this map whose keys are greater than or equal to 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.

Equivalent to tailMap(fromKey, true).

Specified by:

tailMap in interface NavigableMap<K extends Address,V>

Specified by:

tailMap in interface SortedMap<K extends Address,V>

Parameters:

fromKey - low endpoint (inclusive) of the keys in the returned map

Returns:

a view of the portion of this map whose keys are greater than or equal to fromKey

tailMap

public AddressTrieMap<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 extends Address,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

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 extends Address,V>

Returns:

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

firstKey

public K firstKey()

Description copied from interface: java.util.SortedMap

Returns the first (lowest) key currently in this map.

Specified by:

firstKey in interface SortedMap<K extends Address,V>

Returns:

the first (lowest) key currently in this map

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 extends Address,V>

Returns:

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

lastKey

public K lastKey()

Description copied from interface: java.util.SortedMap

Returns the last (highest) key currently in this map.

Specified by:

lastKey in interface SortedMap<K extends Address,V>

Returns:

the last (highest) key currently in this map

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,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

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,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

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,V>

Parameters:

key - the key

Returns:

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

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 extends Address,V>

Returns:

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

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 extends Address,V>

Returns:

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

equals

public boolean equals(Object o)

Description copied from class: java.util.AbstractMap

Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings. More formally, two maps m1 and m2 represent the same mappings if m1.entrySet().equals(m2.entrySet()). This ensures that the equals method works properly across different implementations of the Map interface.

Specified by:

equals in interface Map<K extends Address,V>

Overrides:

equals in class AbstractMap<K extends Address,V>

Parameters:

o - object to be compared for equality with this map

Returns:

true if the specified object is equal to this map

See Also:

Object.hashCode(), HashMap

clone

public AddressTrieMap<K,V> clone()

Clones the map along with the backing trie. If the map had a restricted range, the clone does not.

Overrides:

clone in class AbstractMap<K extends Address,V>

Returns:

a shallow copy of this map

See Also:

Cloneable

comparator

public Comparator<K> comparator()

Description copied from interface: java.util.SortedMap

Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

Specified by:

comparator in interface SortedMap<K extends Address,V>

Returns:

the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys

toTrieString

public String toTrieString()

subMapFromKeysContainedBy

public AddressTrieMap<K,V> subMapFromKeysContainedBy(K addr)

Returns a sub-map consisting of the mappings in the map with address keys contained by the given address The sub-map will have a restricted range matching the range of the given subnet or address.

If the sub-map would be the same size as this map, then this map is returned. The sub-map will the same backing trie as this map.

Parameters:

addr -

Returns:

subMapFromKeysContaining

public AddressTrieMap<K,V> subMapFromKeysContaining(K addr)

Returns a sub-map consisting of the mappings in the map with address keys that contain the given address. The sub-map will have the same restricted range (if any) as this sub-map.

If the sub-map would be the same size as this map, then this map is returned. Otherwise, the sub-map is backed by a new trie.

Parameters:

addr -

Returns:

keyContains

public boolean keyContains(K addr)

Returns true if a subnet or address key in the map contains the given subnet or address.

Parameters:

addr -

Returns:

longestPrefixMatchEntry

public Map.Entry<K,V> longestPrefixMatchEntry(K addr)

Returns the map entry corresponding to the key with the longest prefix match with the given address.

Parameters:

addr -

Returns: