AssociativeAddressTrie (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.format.util.AddressTrie<K>
- - inet.ipaddr.format.util.AssociativeAddressTrie<K,V>

Type Parameters:

K - the type of the address keys

V - the type of the associated values

All Implemented Interfaces:

AddressTrieOps<K>, AddressTrieOps.AddressTrieAddOps<K>, AddressTrieOps.AssociativeAddressTrieOps<K,V>, AddressTrieOps.AssociativeAddressTriePutOps<K,V>, TreeOps<K>, Serializable, Cloneable, Iterable<K>

Direct Known Subclasses:

IPv4AddressAssociativeTrie, IPv6AddressAssociativeTrie, MACAddressAssociativeTrie
```
public abstract class AssociativeAddressTrie<K extends Address,V>
extends AddressTrie<K>
implements AddressTrieOps.AssociativeAddressTriePutOps<K,V>
```
An address trie in which each node is associated with a value.
The trie can also be used as the backing data structure for a AddressTrieMap which is a NavigableMap. Unlike TreeMap this data structure provides access to the nodes and the associated sub-trie with each node as the sub-trie root, which corresponds with their associated CIDR prefix block subnets.
Use one of the put methods to add nodes with values or to change the values of existing nodes. You can also add to the trie using AddressTrie.add(Address) and the associated value will be null.
Mapped tries are thread-safe when not being modified (ie mappings added or removed), but are not thread-safe when a thread is modifying the trie.
To make them thread-safe during addition and removal you could access them through the collection provided by Collections.synchronizedMap(java.util.Map<K, V>), applied to the map from asMap()

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AssociativeAddressTrie.AssociativeTrieNode<K extends Address,V>
- Nested classes/interfaces inherited from class inet.ipaddr.format.util.AddressTrie
  AddressTrie.AddressComparator<E extends Address>, AddressTrie.TrieComparator<E extends Address>, AddressTrie.TrieNode<E extends Address>
- Nested classes/interfaces inherited from interface inet.ipaddr.format.util.AddressTrieOps
  AddressTrieOps.AddressTrieAddOps<E extends Address>, AddressTrieOps.AssociativeAddressTrieOps<K extends Address,V>, AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>

Nested Classes
Modifier and Type	Class and Description
`static class`	`AssociativeAddressTrie.AssociativeTrieNode<K extends Address,V>`

Constructor Summary

Constructors
Constructor and Description

AssociativeAddressTrie(AssociativeAddressTrie.AssociativeTrieNode<K,V> root)

Constructors
Constructor and Description
`AssociativeAddressTrie(AssociativeAddressTrie.AssociativeTrieNode<K,V> root)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`addNode(K addr)` Adds the given single address or prefix block subnet to the trie, if not already there.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`allNodeIterator(boolean forward)` Iterates through the nodes (not just the added nodes) in forward or reverse tree order.
`Spliterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`allNodeSpliterator(boolean forward)` Creates a `Spliterator` over the nodes in forward or reverse natural tree order.
`AddressTrieMap<K,V>`	`asMap()` Returns a java.util.NavigableMap backed by this associative trie.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`blockSizeAllNodeIterator(boolean lowerSubNodeFirst)` Iterates all nodes in the trie, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
`<C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C>`	`blockSizeCachingAllNodeIterator()` Iterates all nodes, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`blockSizeNodeIterator(boolean lowerSubNodeFirst)` Iterates the added nodes in the trie, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`ceilingAddedNode(K addr)` Returns the added node whose address is the lowest address greater than or equal to the given address.
`AssociativeAddressTrie<K,V>`	`clone()` Copies the trie, but not the keys or values.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`containedFirstAllNodeIterator(boolean forwardSubNodeOrder)` Returns an iterator that does a post-order binary tree traversal.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`containedFirstIterator(boolean forwardSubNodeOrder)` Returns an iterator that does a post-order binary tree traversal of the added nodes.
`<C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C>`	`containingFirstAllNodeIterator(boolean lowerSubNodeFirst)` Returns an iterator that does a pre-order binary tree traversal.
`<C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C>`	`containingFirstIterator(boolean lowerSubNodeFirst)` Returns an iterator that does a pre-order binary tree traversal of the added nodes.
`Iterator<E>`	`descendingIterator()` Traverses the added node keys in reverse natural tree order.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`elementsContainedBy(K addr)` Checks if a part of this trie is contained by the given prefix block subnet or individual address.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`elementsContaining(K addr)` Finds the added subnets and/or addresses in the trie that contain the given individual address or prefix block subnet.
`boolean`	`equals(Object o)` Returns whether the given argument is a trie with a set of nodes that equal the set of nodes in this trie
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`firstAddedNode()` Returns the added node with the first (lowest valued) key, or null if there are no added entries in this trie or subtrie
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`firstNode()` Returns the node with the first (lowest valued) key, whether the node is added or not
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`floorAddedNode(K addr)` Returns the added node whose address is the highest address less than or equal to the given address.
`V`	`get(K addr)` Gets the specified value for the specified key in this mapped trie or subtrie.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`getAddedNode(K addr)` Gets trie nodes representing added elements.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`getNode(K addr)` Gets the node corresponding to the given address, returns null if not such element exists.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`getRoot()` Returns the root of this trie
`int`	`hashCode()` Returns a hash code value for the object.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`higherAddedNode(K addr)` Returns the added node whose address is the lowest address strictly greater than the given address.
`Iterator<E>`	`iterator()` Traverses the added node keys in natural tree order.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`lastAddedNode()` Returns the added node with the last (highest valued) key, or null if there are no added elements in this trie or subtrie
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`lastNode()` Returns the node with the last (highest valued) key, whether the node is added or not
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`longestPrefixMatchNode(K addr)` Finds the containing subnet or address in the trie with the smallest subnet size, which is equivalent to finding the subnet or address with the longest matching prefix.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`lowerAddedNode(K addr)` Returns the added node whose address is the highest address strictly less than the given address.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`nodeIterator(boolean forward)` Iterates through the added nodes in forward or reverse natural tree order.
`Spliterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`nodeSpliterator(boolean forward)` Creates a `Spliterator` over the added nodes in forward or reverse natural tree order.
`V`	`put(K addr, V value)` Associates the specified value with the specified key in this map.
`boolean`	`putNew(K addr, V value)` Associates the specified value with the specified key in this map.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`putNode(K addr, V value)` Associates the specified value with the specified key in this map.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`putTrie(AssociativeAddressTrie.AssociativeTrieNode<K,V> trie)` Adds nodes matching the given sub-root node and all of its sub-nodes to the trie, if not already there.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`remap(K addr, Function<? super V,? extends V> remapper)` Remaps node values in the trie.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`remapIfAbsent(K addr, Supplier<? extends V> remapper, boolean insertNull)` Remaps node values in the trie, but only for nodes that do not exist or are mapped to null.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`removeElementsContainedBy(K addr)` Removes any single address or prefix block subnet from the trie that is contained in the given individual address or prefix block subnet.

Methods inherited from class inet.ipaddr.format.util.AddressTrie
add, addTrie, asSet, clear, constructAddedNodesTree, contains, decrement, descendingSpliterator, elementContains, getComparator, increment, isEmpty, longestPrefixMatch, nodeSize, remove, size, spliterator, toAddedNodesTreeString, toString, toString, toString

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface inet.ipaddr.format.util.AddressTrieOps
contains, elementContains, longestPrefixMatch, remove

Methods inherited from interface inet.ipaddr.format.util.TreeOps
descendingIterator, descendingSpliterator, iterator, spliterator

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - AssociativeAddressTrie
```
public AssociativeAddressTrie(AssociativeAddressTrie.AssociativeTrieNode<K,V> root)
```
- Method Detail
  - getRoot
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getRoot()
```
    Returns the root of this trie
    
    Overrides:
    
    getRoot in class AddressTrie<K extends Address>
    
    Returns:
  - put
```
public V put(K addr,
             V value)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Associates the specified value with the specified key in this map.
    Unlike AddressTrieOps.AssociativeAddressTriePutOps.putNew(Address, Object), AddressTrieOps.AssociativeAddressTriePutOps.put(Address, Object) can provide the value to which to key was previously mapped.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    If this map previously contained a mapping for a key, the old value is replaced by the specified value, and the old value is returned. If this map did not previously contain a mapping for the key, null is returned.
    
    Specified by:
    
    put in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    Returns:
  - putNew
```
public boolean putNew(K addr,
                      V value)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Associates the specified value with the specified key in this map.
    Unlike AddressTrieOps.AssociativeAddressTriePutOps.put(Address, Object), AddressTrieOps.AssociativeAddressTriePutOps.put(Address, Object) can distinguish between cases where the call results in a new entry, and cases where the call matched a previous entry that was mapped to null.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    If this map previously contained a mapping for a key, the old value is replaced by the specified value, and false is returned. If this map did not previously contain a mapping for the key, true is returned.
    
    Specified by:
    
    putNew in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    Returns:
  - addNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> addNode(K addr)
```
    Description copied from interface: AddressTrieOps.AddressTrieAddOps
    
    Adds the given single address or prefix block subnet to the trie, if not already there.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns the node for the added address, whether it was already in the trie or not.
    If you wish to know whether the node was already there when adding, use AddressTrieOps.AddressTrieAddOps.add(Address), or before adding you can use AddressTrieOps.getAddedNode(Address)
    
    Specified by:
    
    addNode in interface AddressTrieOps.AddressTrieAddOps<K extends Address>
    
    Overrides:
    
    addNode in class AddressTrie<K extends Address>
    
    Returns:
  - putTrie
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> putTrie(AssociativeAddressTrie.AssociativeTrieNode<K,V> trie)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Adds nodes matching the given sub-root node and all of its sub-nodes to the trie, if not already there.
    For each added in the given node that does not exist in the trie, a copy of each node will be made that matches the trie type (associative or not), the copy including the associated value, and the copy will be inserted into the trie.
    The node type need not match the node type of the trie, although the address type/version E must match. So this means you can add non-associative nodes with this method, in which case, the new nodes will be associative but will be mapped to null.
    When adding one trie to another, this method is more efficient than adding each node of the first trie individually. When using this method, searching for the location to add sub-nodes starts from the inserted parent node.
    Returns the node corresponding to the given sub-root node, whether it was already in the trie or not.
    
    Specified by:
    
    putTrie in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    Returns:
  - putNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> putNode(K addr,
                                                               V value)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Associates the specified value with the specified key in this map.
    Unlike AddressTrieOps.AssociativeAddressTriePutOps.put(Address, Object), AddressTrieOps.AssociativeAddressTriePutOps.put(Address, Object) can distinguish between cases where the call results in a new entry, and cases where the call matched a previous entry that was mapped to null.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns the node for the added address, whether it was already in the tree or not.
    If you wish to know whether the node was already there when adding, use AddressTrieOps.AssociativeAddressTriePutOps.putNew(Address, Object), or before adding you can use AddressTrieOps.getAddedNode(Address)
    
    Specified by:
    
    putNode in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    Returns:
  - remap
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> remap(K addr,
                                                             Function<? super V,? extends V> remapper)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Remaps node values in the trie.
    This will lookup the node corresponding to the given key. It will call the remapping function with the key as the first argument, regardless of whether the node is found or not.
    If the node is not found, the value argument will be null. If the node is found, the value argument will be the node's value, which can also be null.
    If the remapping function returns null, then the matched node will be removed, if any. If it returns a non-null value, then it will either set the existing node to have that value, or if there was no matched node, it will create a new node with that value.
    The method will return the node involved, which is either the matched node, or the newly created node, or null if there was no matched node nor newly created node.
    If the remapping function modifies the trie during its computation, and the returned value specifies changes to be made, then the trie will not be changed and ConcurrentModificationException will be thrown instead.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    
    Specified by:
    
    remap in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    Returns:
  - remapIfAbsent
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> remapIfAbsent(K addr,
                                                                     Supplier<? extends V> remapper,
                                                                     boolean insertNull)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTriePutOps
    
    Remaps node values in the trie, but only for nodes that do not exist or are mapped to null.
    This will look up the node corresponding to the given key. If the node is not found or mapped to null, this will call the remapping function.
    If the remapping function returns a non-null value, then it will either set the existing node to have that value, or if there was no matched node, it will create a new node with that value. If the remapping function returns null, then it will do the same if insertNull is true, otherwise it will do nothing.
    The method will return the node involved, which is either the matched node, or the newly created node, or null if there was no matched node nor newly created node.
    If the remapping function modifies the trie during its computation, and the returned value specifies changes to be made, then the trie will not be changed and ConcurrentModificationException will be thrown instead.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    
    Specified by:
    
    remapIfAbsent in interface AddressTrieOps.AssociativeAddressTriePutOps<K extends Address,V>
    
    insertNull - whether null values returned from remapper should be inserted into the map, or whether null values indicate no remapping
    
    Returns:
  - get
```
public V get(K addr)
```
    Description copied from interface: AddressTrieOps.AssociativeAddressTrieOps
    
    Gets the specified value for the specified key in this mapped trie or subtrie.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns the value for the given key. Returns null if the contains no mapping for that key or if the mapped value is null.
    
    Specified by:
    
    get in interface AddressTrieOps.AssociativeAddressTrieOps<K extends Address,V>
    
    Returns:
  - getAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getAddedNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Gets trie nodes representing added elements.
    Use AddressTrieOps.contains(Address) to check for the existence of a given address in the trie, as well as AddressTrieOps.getNode(Address) to search for all nodes including those not-added but also auto-generated nodes for subnet blocks.
    
    Specified by:
    
    getAddedNode in interface AddressTrieOps<K extends Address>
    
    Returns:
  - getNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Gets the node corresponding to the given address, returns null if not such element exists.
    If added is true, returns only nodes representing added elements, otherwise returns any node, including a prefix block that was not added.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    
    Specified by:
    
    getNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    getNode in class AddressTrie<K extends Address>
    
    Returns:
    
    See Also:
    
    AddressTrieOps.contains(Address)
  - removeElementsContainedBy
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> removeElementsContainedBy(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Removes any single address or prefix block subnet from the trie that is contained in the given individual address or prefix block subnet.
    Goes further than AddressTrieOps.remove(Address), not requiring a match to an inserted node, and also removing all the sub-nodes of any removed node or sub-node.
    For example, after inserting 1.2.3.0 and 1.2.3.1, passing 1.2.3.0/31 to AddressTrieOps.removeElementsContainedBy(Address) will remove them both, while AddressTrieOps.remove(Address) will remove nothing. After inserting 1.2.3.0/31, then #remove(Address) will remove 1.2.3.0/31, but will leave 1.2.3.0 and 1.2.3.1 in the trie.
    It cannot partially delete a node, such as deleting a single address from a prefix block represented by a node. It can only delete the whole node if the whole address or block represented by that node is contained in the given address or block.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns the root node of the subtrie that was removed from the trie, or null if nothing was removed.
    
    Specified by:
    
    removeElementsContainedBy in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    removeElementsContainedBy in class AddressTrie<K extends Address>
    
    Returns:
  - elementsContainedBy
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> elementsContainedBy(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Checks if a part of this trie is contained by the given prefix block subnet or individual address.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns the root node of the contained subtrie, or null if no subtrie is contained. The node returned need not be an "added" node, see BinaryTreeNode.isAdded() for more details on added nodes. The returned subtrie is backed by this trie, so changes in this trie are reflected in those nodes and vice-versa.
    
    Specified by:
    
    elementsContainedBy in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    elementsContainedBy in class AddressTrie<K extends Address>
    
    Returns:
  - elementsContaining
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> elementsContaining(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Finds the added subnets and/or addresses in the trie that contain the given individual address or prefix block subnet.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns a list of the nodes for prefix block subnets and addresses from the trie that contain the address or block. The list consists only of added nodes, see BinaryTreeNode.isAdded() for more details on added nodes. The list is constructed as a trie in which each parent node has only one sub-node.
    Use AddressTrieOps.elementContains(Address) to check for the existence of a containing address.
    
    Specified by:
    
    elementsContaining in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    elementsContaining in class AddressTrie<K extends Address>
    
    Returns:
  - longestPrefixMatchNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> longestPrefixMatchNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Finds the containing subnet or address in the trie with the smallest subnet size, which is equivalent to finding the subnet or address with the longest matching prefix. Returns the node corresponding to that subnet.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    If not a single address nor prefix block, the Partition class can be used to convert the address before calling this method. See AddressTrieOps.AddressTrieAddOps.add(Address) for more details.
    Returns null if no added subnet or address contains the given argument.
    Use AddressTrieOps.elementContains(Address) to check for the existence of a containing address.
    To get all the containing addresses, use AddressTrieOps.elementsContaining(Address).
    Use AddressTrieOps.longestPrefixMatch(Address) to get the address corresponding to the result of this method.
    
    Specified by:
    
    longestPrefixMatchNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    longestPrefixMatchNode in class AddressTrie<K extends Address>
    
    Returns:
  - asMap
```
public AddressTrieMap<K,V> asMap()
```
    Returns a java.util.NavigableMap backed by this associative trie. The added elements of this trie are keys for the map, the associated values are the map values.
    
    Returns:
  - nodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> nodeIterator(boolean forward)
```
    Description copied from interface: TreeOps
    
    Iterates through the added nodes in forward or reverse natural tree order.
    This iterator supports the Iterator.remove() operation.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    nodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    nodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    nodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - allNodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> allNodeIterator(boolean forward)
```
    Description copied from interface: TreeOps
    
    Iterates through the nodes (not just the added nodes) in forward or reverse tree order.
    
    See TreeOps for more details on the ordering. This iterator supports the Iterator.remove() operation.
    
    Specified by:
    
    allNodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    allNodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    allNodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - blockSizeCachingAllNodeIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> blockSizeCachingAllNodeIterator()
```
    Description copied from class: AddressTrie
    
    Iterates all nodes, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
    This iterator supports the Iterator.remove() operation.
    
    Overrides:
    
    blockSizeCachingAllNodeIterator in class AddressTrie<K extends Address>
    
    Returns:
  - blockSizeNodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> blockSizeNodeIterator(boolean lowerSubNodeFirst)
```
    Description copied from class: AddressTrie
    
    Iterates the added nodes in the trie, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
    This iterator supports the Iterator.remove() operation.
    
    Overrides:
    
    blockSizeNodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    lowerSubNodeFirst - if true, for blocks of equal size the lower is first, otherwise the reverse order
    
    Returns:
  - blockSizeAllNodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> blockSizeAllNodeIterator(boolean lowerSubNodeFirst)
```
    Description copied from class: AddressTrie
    
    Iterates all nodes in the trie, ordered by keys from largest prefix blocks to smallest, and then to individual addresses.
    This iterator supports the Iterator.remove() operation.
    
    Overrides:
    
    blockSizeAllNodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    lowerSubNodeFirst - if true, for blocks of equal size the lower is first, otherwise the reverse order
    
    Returns:
  - containingFirstIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> containingFirstIterator(boolean lowerSubNodeFirst)
```
    Description copied from interface: TreeOps
    
    Returns an iterator that does a pre-order binary tree traversal of the added nodes. All added nodes will be visited before their added sub-nodes. For an address trie this means added containing subnet blocks will be visited before their added contained addresses and subnet blocks.
    This iterator supports the Iterator.remove() operation.
    Once a given node is visited, the iterator allows you to cache an object corresponding to the lower or upper sub-node that can be retrieved when you later visit that sub-node.
    Objects are cached only with nodes to be visited. So for this iterator that means an object will be cached with the first added lower or upper sub-node, the next lower or upper sub-node to be visited, which is not necessarily the direct lower or upper sub-node of a given node.
    The caching allows you to provide iteration context from a parent to its sub-nodes when iterating. The caching and retrieval is done in constant-time and linear space (proportional to tree size).
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    containingFirstIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    containingFirstIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    containingFirstIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    lowerSubNodeFirst - if true, a left sub-node will be visited before the right sub-node of the same parent node.
    
    Returns:
  - containingFirstAllNodeIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> containingFirstAllNodeIterator(boolean lowerSubNodeFirst)
```
    Description copied from interface: TreeOps
    Returns an iterator that does a pre-order binary tree traversal. All nodes will be visited before their sub-nodes. For an address trie this means containing subnet blocks will be visited before their contained addresses and subnet blocks.
    This iterator supports the Iterator.remove() operation.
    Once a given node is visited, the iterator allows you to cache an object corresponding to the lower or upper sub-node that can be retrieved when you later visit that sub-node. That allows you to provide iteration context from a parent to its sub-nodes when iterating. The caching and retrieval is done in constant-time and linear space (proportional to tree size).
    Here is an example showing usage of the caching. Consider this recursive code doing a pre-order traversal:
```
IPv6AddressTrie ipv6Tree = ...;
visitRecursive(ipv6Tree.getRoot(), null);

static <E> void visitRecursive(BinaryTreeNode<E> node, String direction) {
        if(direction == null) {
                direction = "root";
        }
        System.out.println("visited " + direction + " " + node);
        BinaryTreeNode<E> sub = node.getLowerSubNode();
        if(sub != null) {
                visitRecursive(sub, direction + " left");
        }
        sub = node.getUpperSubNode();
        if(sub != null) {
                visitRecursive(sub, direction + " right");
        }
}
```
    The following iterative code provides the same functionality:
```
visitIterative(ipv6Tree.getRoot());

static <E> void visitIterative(BinaryTreeNode<E> node) {    
        CachingIterator<? extends BinaryTreeNode<E>, E, String>iterator = node.containingFirstAllNodeIterator(true);
        while(iterator.hasNext()) {
                BinaryTreeNode<E> next = iterator.next();
                String direction = iterator.getCached();
                if(direction == null) {
                        direction = "root";
                }
                System.out.println("visited " + direction + " " + next);
                iterator.cacheWithLowerSubNode(direction + " left");
                iterator.cacheWithUpperSubNode(direction + " right");
        }
}
 
```
    See TreeOps for more details on the ordering.
    Specified by:
    
    containingFirstAllNodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    containingFirstAllNodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    containingFirstAllNodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    lowerSubNodeFirst - if true, a left sub-node will be visited before the right sub-node of the same parent node.
    
    Returns:
  - containedFirstIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> containedFirstIterator(boolean forwardSubNodeOrder)
```
    Description copied from interface: TreeOps
    
    Returns an iterator that does a post-order binary tree traversal of the added nodes. All added sub-nodes will be visited before their parent nodes. For an address trie this means contained addresses and subnets will be visited before their containing subnet blocks.
    This iterator supports the Iterator.remove() operation.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    containedFirstIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    containedFirstIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    containedFirstIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forwardSubNodeOrder - if true, a left sub-node will be visited before the right sub-node of the same parent node.
    
    Returns:
  - containedFirstAllNodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> containedFirstAllNodeIterator(boolean forwardSubNodeOrder)
```
    Description copied from interface: TreeOps
    
    Returns an iterator that does a post-order binary tree traversal. All sub-nodes will be visited before their parent nodes. For an address trie this means contained addresses and subnets will be visited before their containing subnet blocks.
    This iterator does not support the Iterator.remove() operation. If Iterator.remove() is called it will throw UnsupportedOperationException.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    containedFirstAllNodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    containedFirstAllNodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    containedFirstAllNodeIterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forwardSubNodeOrder - if true, a left sub-node will be visited before the right sub-node of the same parent node.
    
    Returns:
  - nodeSpliterator
```
public Spliterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> nodeSpliterator(boolean forward)
```
    Description copied from interface: TreeOps
    
    Creates a Spliterator over the added nodes in forward or reverse natural tree order.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    nodeSpliterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    nodeSpliterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    nodeSpliterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - allNodeSpliterator
```
public Spliterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> allNodeSpliterator(boolean forward)
```
    Description copied from interface: TreeOps
    
    Creates a Spliterator over the nodes in forward or reverse natural tree order.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    allNodeSpliterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    allNodeSpliterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    allNodeSpliterator in class AddressTrie<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - firstNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> firstNode()
```
    Description copied from interface: AddressTrieOps
    
    Returns the node with the first (lowest valued) key, whether the node is added or not
    
    Specified by:
    
    firstNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    firstNode in class AddressTrie<K extends Address>
    
    Returns:
  - lastNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> lastNode()
```
    Description copied from interface: AddressTrieOps
    
    Returns the node with the last (highest valued) key, whether the node is added or not
    
    Specified by:
    
    lastNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    lastNode in class AddressTrie<K extends Address>
    
    Returns:
  - firstAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> firstAddedNode()
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node with the first (lowest valued) key, or null if there are no added entries in this trie or subtrie
    
    Specified by:
    
    firstAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    firstAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - lastAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> lastAddedNode()
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node with the last (highest valued) key, or null if there are no added elements in this trie or subtrie
    
    Specified by:
    
    lastAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    lastAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - lowerAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> lowerAddedNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node whose address is the highest address strictly less than the given address.
    
    Specified by:
    
    lowerAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    lowerAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - floorAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> floorAddedNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node whose address is the highest address less than or equal to the given address.
    
    Specified by:
    
    floorAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    floorAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - higherAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> higherAddedNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node whose address is the lowest address strictly greater than the given address.
    
    Specified by:
    
    higherAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    higherAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - ceilingAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> ceilingAddedNode(K addr)
```
    Description copied from interface: AddressTrieOps
    
    Returns the added node whose address is the lowest address greater than or equal to the given address.
    
    Specified by:
    
    ceilingAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    ceilingAddedNode in class AddressTrie<K extends Address>
    
    Returns:
  - clone
```
public AssociativeAddressTrie<K,V> clone()
```
    Copies the trie, but not the keys or values.
    
    Overrides:
    
    clone in class AddressTrie<K extends Address>
    
    Returns:
    
    a clone of this instance.
    
    See Also:
    
    Cloneable
  - equals
```
public boolean equals(Object o)
```
    Description copied from class: AddressTrie
    
    Returns whether the given argument is a trie with a set of nodes that equal the set of nodes in this trie
    
    Overrides:
    
    equals in class AddressTrie<K extends Address>
    
    Parameters:
    
    o - the reference object with which to compare.
    
    Returns:
    
    true if this object is the same as the obj argument; false otherwise.
    
    See Also:
    
    Object.hashCode(), HashMap
  - iterator
```
public Iterator<E> iterator()
```
    Description copied from interface: TreeOps
    
    Traverses the added node keys in natural tree order.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    iterator in interface TreeOps<E extends Address>
    
    Specified by:
    
    iterator in interface Iterable<E extends Address>
    
    Returns:
    
    an Iterator.
  - descendingIterator
```
public Iterator<E> descendingIterator()
```
    Description copied from interface: TreeOps
    
    Traverses the added node keys in reverse natural tree order.
    See TreeOps for more details on the ordering.
    
    Specified by:
    
    descendingIterator in interface TreeOps<E extends Address>
    
    Returns:
  - hashCode
```
public int hashCode()
```
    Description copied from class: java.lang.Object
    Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by HashMap.
    The general contract of hashCode is:
    - Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
    - If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
    - It is not required that if two objects are unequal according to the Object.equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.
    As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java™ programming language.)
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    a hash code value for this object.
    
    See Also:
    
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)

Class AssociativeAddressTrie<K extends Address,V>

Nested Class Summary

Nested classes/interfaces inherited from class inet.ipaddr.format.util.AddressTrie

Nested classes/interfaces inherited from interface inet.ipaddr.format.util.AddressTrieOps

Constructor Summary

Method Summary

Methods inherited from class inet.ipaddr.format.util.AddressTrie

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.format.util.AddressTrieOps

Methods inherited from interface inet.ipaddr.format.util.TreeOps

Methods inherited from interface java.lang.Iterable

Constructor Detail

AssociativeAddressTrie

Method Detail

getRoot

put

putNew

addNode

putTrie

putNode

remap

remapIfAbsent

get

getAddedNode

getNode

removeElementsContainedBy

elementsContainedBy

elementsContaining

longestPrefixMatchNode

asMap

nodeIterator

allNodeIterator

blockSizeCachingAllNodeIterator

blockSizeNodeIterator

blockSizeAllNodeIterator

containingFirstIterator

containingFirstAllNodeIterator

containedFirstIterator

containedFirstAllNodeIterator

nodeSpliterator

allNodeSpliterator

firstNode

lastNode

firstAddedNode

lastAddedNode

lowerAddedNode

floorAddedNode

higherAddedNode

ceilingAddedNode

clone

equals

iterator

descendingIterator

hashCode