AssociativeAddressTrie.AssociativeTrieNode (IPAddress javadoc by seancfoley)

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

All Implemented Interfaces:

AddressTrieOps<K>, AddressTrieOps.AssociativeAddressTrieOps<K,V>, TreeOps<K>, Serializable, Cloneable, Iterable<K>, Map.Entry<K,V>

Direct Known Subclasses:

IPv4AddressAssociativeTrie.IPv4AssociativeTrieNode, IPv6AddressAssociativeTrie.IPv6AssociativeTrieNode, MACAddressAssociativeTrie.MACAssociativeTrieNode

Enclosing class:

AssociativeAddressTrie<K extends Address,V>
```
public abstract static class AssociativeAddressTrie.AssociativeTrieNode<K extends Address,V>
extends AddressTrie.TrieNode<K>
implements Map.Entry<K,V>, AddressTrieOps.AssociativeAddressTrieOps<K,V>
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class inet.ipaddr.format.util.BinaryTreeNode
  BinaryTreeNode.CachingIterator<N extends BinaryTreeNode<E>,E,C>
- 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>

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`allNodeIterator(boolean forward)` Iterates through all the nodes of the sub-tree with this node as the root, 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.
`AssociativeAddressTrie<K,V>`	`asNewTrie()` Creates a new sub-trie, copying the nodes starting with this node as root.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`blockSizeAllNodeIterator(boolean lowerSubNodeFirst)` Iterates all the nodes, ordered by keys from largest prefix blocks to smallest and then to individual addresses, in the sub-trie with this node as the root.
`<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, in the sub-trie with this node as the root.
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`blockSizeNodeIterator(boolean lowerSubNodeFirst)` Iterates the added nodes, ordered by keys from largest prefix blocks to smallest and then to individual addresses, in the sub-trie with this node as the root.
`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.
`void`	`clearValue()`
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`clone()` Clones the node.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`cloneTree()` Clones the subtrie starting with this node as root.
`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 forwardSubNodeOrder)` Returns an iterator that does a pre-order binary tree traversal.
`<C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C>`	`containingFirstIterator(boolean forwardSubNodeOrder)` Returns an iterator that does a pre-order binary tree traversal of the added nodes.
`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 key and mapped value match those of the given node
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`firstAddedNode()` Returns the first (lowest valued) added node in the sub-tree originating from this node, or null if there are no added entries in this tree or sub-tree
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`firstNode()` Returns the first (lowest valued) node in the sub-tree originating from this node.
`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>`	`getLowerSubNode()` Returns the sub node whose address is smallest in value
`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>`	`getParent()` Returns the node for the subnet block containing this node.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`getUpperSubNode()` Returns the sub-node whose address is largest in value
`V`	`getValue()`
`int`	`hashCode()` The hash code is the same as that specified by `Map.Entry.hashCode()`
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`higherAddedNode(K addr)` Returns the added node whose address is the lowest address strictly greater than the given address.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`lastAddedNode()` Returns the last (highest valued) added node in the sub-tree originating from this node, or null if there are no added entries in this tree or sub-tree
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`lastNode()` Returns the last (highest valued) node in the sub-tree originating from this node.
`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.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`nextAddedNode()` Returns the next node in the tree that is an added node, following the tree order, or null if there is no such node.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`nextNode()` Returns the node that follows this node following the tree order
`Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>>`	`nodeIterator(boolean forward)` Iterates through the added nodes of the sub-tree with this node as the root, in forward or reverse 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.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`previousAddedNode()` Returns the previous node in the tree that is an added node, following the tree order in reverse, or null if there is no such node.
`AssociativeAddressTrie.AssociativeTrieNode<K,V>`	`previousNode()` Returns the node that precedes this node following the tree order.
`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.
`V`	`setValue(V value)`
`String`	`toString()` Returns a visual representation of this node including the key, with an open circle indicating this node is not an added node, a closed circle indicating this node is an added node.

Methods inherited from class inet.ipaddr.format.util.AddressTrie.TrieNode
ceiling, contains, descendingSpliterator, elementContains, floor, higher, longestPrefixMatch, lower, remove, shortestPrefixMatch, shortestPrefixMatchNode, spliterator

Methods inherited from class inet.ipaddr.format.util.BinaryTreeNode
clear, descendingIterator, getKey, isAdded, isEmpty, isLeaf, isRoot, iterator, nodeSize, remove, setAdded, size, toTreeString, treeEquals, treeHashCode

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

Methods inherited from interface java.util.Map.Entry
comparingByKey, comparingByKey, comparingByValue, comparingByValue, getKey

Methods inherited from interface inet.ipaddr.format.util.AddressTrieOps
ceiling, contains, elementContains, floor, higher, longestPrefixMatch, lower, remove, shortestPrefixMatch, shortestPrefixMatchNode

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

Methods inherited from interface java.lang.Iterable
forEach

- Method Detail
  - getValue
```
public V getValue()
```
    Specified by:
    
    getValue in interface Map.Entry<K extends Address,V>
  - setValue
```
public V setValue(V value)
```
    Specified by:
    
    setValue in interface Map.Entry<K extends Address,V>
  - clearValue
```
public void clearValue()
```
  - getUpperSubNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getUpperSubNode()
```
    Description copied from class: AddressTrie.TrieNode
    
    Returns the sub-node whose address is largest in value
    
    Overrides:
    
    getUpperSubNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - getLowerSubNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getLowerSubNode()
```
    Description copied from class: AddressTrie.TrieNode
    
    Returns the sub node whose address is smallest in value
    
    Overrides:
    
    getLowerSubNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - getParent
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> getParent()
```
    Description copied from class: AddressTrie.TrieNode
    
    Returns the node for the subnet block containing this node.
    
    Overrides:
    
    getParent in class AddressTrie.TrieNode<K extends Address>
    
    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:
  - hashCode
```
public int hashCode()
```
    The hash code is the same as that specified by Map.Entry.hashCode()
    
    Specified by:
    
    hashCode in interface Map.Entry<K extends Address,V>
    
    Overrides:
    
    hashCode in class BinaryTreeNode<K extends Address>
  - asNewTrie
```
public AssociativeAddressTrie<K,V> asNewTrie()
```
    Description copied from class: AddressTrie.TrieNode
    
    Creates a new sub-trie, copying the nodes starting with this node as root. The nodes are copies of the nodes in this sub-trie, but their keys and values are not copies.
    
    Overrides:
    
    asNewTrie in class AddressTrie.TrieNode<K extends Address>
  - cloneTree
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> cloneTree()
```
    Clones the subtrie starting with this node as root. The nodes are cloned, the keys and values are not cloned.
    
    Overrides:
    
    cloneTree in class AddressTrie.TrieNode<K extends Address>
  - clone
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> clone()
```
    Clones the node. Keys and values are not cloned, but parent node, lower and upper sub-nodes, are all set to null.
    
    Overrides:
    
    clone in class AddressTrie.TrieNode<K extends Address>
  - equals
```
public boolean equals(Object o)
```
    Returns whether the key and mapped value match those of the given node
    
    Specified by:
    
    equals in interface Map.Entry<K extends Address,V>
    
    Overrides:
    
    equals in class AddressTrie.TrieNode<K extends Address>
  - nodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> nodeIterator(boolean forward)
```
    Description copied from class: BinaryTreeNode
    
    Iterates through the added nodes of the sub-tree with this node as the root, in forward or reverse tree order.
    
    Specified by:
    
    nodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    nodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    nodeIterator in class AddressTrie.TrieNode<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 class: BinaryTreeNode
    
    Iterates through all the nodes of the sub-tree with this node as the root, in forward or reverse tree order.
    
    Specified by:
    
    allNodeIterator in interface AddressTrieOps<K extends Address>
    
    Specified by:
    
    allNodeIterator in interface TreeOps<K extends Address>
    
    Overrides:
    
    allNodeIterator in class AddressTrie.TrieNode<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - blockSizeNodeIterator
```
public Iterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>> blockSizeNodeIterator(boolean lowerSubNodeFirst)
```
    Description copied from class: AddressTrie.TrieNode
    
    Iterates the added nodes, ordered by keys from largest prefix blocks to smallest and then to individual addresses, in the sub-trie with this node as the root.
    This iterator supports the Iterator.remove() operation.
    
    Overrides:
    
    blockSizeNodeIterator in class AddressTrie.TrieNode<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.TrieNode
    
    Iterates all the nodes, ordered by keys from largest prefix blocks to smallest and then to individual addresses, in the sub-trie with this node as the root.
    This iterator supports the Iterator.remove() operation.
    
    Overrides:
    
    blockSizeAllNodeIterator in class AddressTrie.TrieNode<K extends Address>
    
    Parameters:
    
    lowerSubNodeFirst - if true, for blocks of equal size the lower is first, otherwise the reverse order
    
    Returns:
  - blockSizeCachingAllNodeIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> blockSizeCachingAllNodeIterator()
```
    Description copied from class: AddressTrie.TrieNode
    
    Iterates all nodes, ordered by keys from largest prefix blocks to smallest and then to individual addresses, in the sub-trie with this node as the root.
    
    Overrides:
    
    blockSizeCachingAllNodeIterator in class AddressTrie.TrieNode<K extends Address>
  - containingFirstIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> containingFirstIterator(boolean forwardSubNodeOrder)
```
    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.TrieNode<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:
  - containingFirstAllNodeIterator
```
public <C> BinaryTreeNode.CachingIterator<? extends AssociativeAddressTrie.AssociativeTrieNode<K,V>,K,C> containingFirstAllNodeIterator(boolean forwardSubNodeOrder)
```
    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.TrieNode<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:
  - 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.TrieNode<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.TrieNode<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.TrieNode<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.TrieNode<K extends Address>
    
    Parameters:
    
    forward - if true, goes in ascending order, otherwise descending
    
    Returns:
  - previousAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> previousAddedNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the previous node in the tree that is an added node, following the tree order in reverse, or null if there is no such node.
    
    Overrides:
    
    previousAddedNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - nextAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> nextAddedNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the next node in the tree that is an added node, following the tree order, or null if there is no such node.
    
    Overrides:
    
    nextAddedNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - nextNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> nextNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the node that follows this node following the tree order
    
    Overrides:
    
    nextNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - previousNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> previousNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the node that precedes this node following the tree order.
    
    Overrides:
    
    previousNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - firstNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> firstNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the first (lowest valued) node in the sub-tree originating from this node.
    
    Specified by:
    
    firstNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    firstNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - lastNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> lastNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the last (highest valued) node in the sub-tree originating from this node.
    
    Specified by:
    
    lastNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    lastNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - firstAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> firstAddedNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the first (lowest valued) added node in the sub-tree originating from this node, or null if there are no added entries in this tree or sub-tree
    
    Specified by:
    
    firstAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    firstAddedNode in class AddressTrie.TrieNode<K extends Address>
    
    Returns:
  - lastAddedNode
```
public AssociativeAddressTrie.AssociativeTrieNode<K,V> lastAddedNode()
```
    Description copied from class: BinaryTreeNode
    
    Returns the last (highest valued) added node in the sub-tree originating from this node, or null if there are no added entries in this tree or sub-tree
    
    Specified by:
    
    lastAddedNode in interface AddressTrieOps<K extends Address>
    
    Overrides:
    
    lastAddedNode in class AddressTrie.TrieNode<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.TrieNode<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.TrieNode<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.TrieNode<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.TrieNode<K extends Address>
    
    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.TrieNode<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.TrieNode<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.TrieNode<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.TrieNode<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.TrieNode<K extends Address>
    
    Returns:
  - toString
```
public String toString()
```
    Description copied from class: BinaryTreeNode
    
    Returns a visual representation of this node including the key, with an open circle indicating this node is not an added node, a closed circle indicating this node is an added node.
    
    Overrides:
    
    toString in class BinaryTreeNode<K extends Address>

Class AssociativeAddressTrie.AssociativeTrieNode<K extends Address,V>

Nested Class Summary

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

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

Method Summary

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map.Entry

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

Method Detail

getValue

setValue

clearValue

getUpperSubNode

getLowerSubNode

getParent

get

hashCode

asNewTrie

cloneTree

clone

equals

nodeIterator

allNodeIterator

blockSizeNodeIterator

blockSizeAllNodeIterator

blockSizeCachingAllNodeIterator

containingFirstIterator

containingFirstAllNodeIterator

containedFirstIterator

containedFirstAllNodeIterator

nodeSpliterator

allNodeSpliterator

previousAddedNode

nextAddedNode

nextNode

previousNode

firstNode

lastNode

firstAddedNode

lastAddedNode

lowerAddedNode

floorAddedNode

higherAddedNode

ceilingAddedNode

getAddedNode

getNode

removeElementsContainedBy

elementsContainedBy

elementsContaining

longestPrefixMatchNode

toString