AddressTrieSet (IPAddress javadoc by seancfoley)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractSet<E>
  - - inet.ipaddr.format.util.AddressTrieSet<E>

Type Parameters:

E - the address type

All Implemented Interfaces:

Serializable, Cloneable, Iterable<E>, Collection<E>, NavigableSet<E>, Set<E>, SortedSet<E>
```
public class AddressTrieSet<E extends Address>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable
```
Wraps a AddressTrie to view it as a Java Collections Framework set, implementing the Set, SortedSet and NavigableSet interfaces.
Like TreeSet, this set is backed by a binary tree and implements the same interfaces that TreeSet does. But there are some significant differences between the two binary tree implementations. See AddressTrieMap for a description of some of the differences. TreeMap is backed by a TreeSet and AddressTrieMap is backed by an AddressTrie just like AddressTrie, so all of the same implementation comparisons apply equally between the map implementations and the set implementations.
With the trie set, 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 collection, address instances that are not individual address or prefix block subnets, you can use TreeSet or any other Java collections framework set to store addresses of any type, or addresses of different versions or types in the same set, 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 AddressTrieSet.Range<E extends Address>

Nested Classes
Modifier and Type	Class and Description
`static class`	`AddressTrieSet.Range<E extends Address>`

Constructor Summary

Constructors
Constructor and Description

AddressTrieSet(AddressTrie<E> trie)

AddressTrieSet(AddressTrie<E> trie, Collection<? extends E> collection)

Constructors
Constructor and Description
`AddressTrieSet(AddressTrie<E> trie)`
`AddressTrieSet(AddressTrie<E> trie, Collection<? extends E> collection)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)` Adds the given single address or prefix block subnet to this set.
`AddressTrie<E>`	`asTrie()` Returns a trie representing this set.
`Iterator<E>`	`blockSizeIterator()` Iterates from largest prefix blocks to smallest to individual addresses.
`E`	`ceiling(E e)` Returns the least element in this set greater than or equal to the given element, or `null` if there is no such element.
`void`	`clear()` Removes all of the elements from this collection (optional operation).
`AddressTrieSet<E>`	`clone()` Clones the set along with the backing trie.
`Comparator<E>`	`comparator()` Returns the comparator used to order the elements in this set, or `null` if this set uses the natural ordering of its elements.
`Iterator<E>`	`containedFirstIterator()` Returns an iterator that visits contained addresses and subnet blocks before their containing subnet blocks.
`Iterator<E>`	`containingFirstIterator()` Returns an iterator that visits containing subnet blocks before their contained addresses and subnet blocks.
`boolean`	`contains(Object o)` Returns `true` if this collection contains the specified element.
`Iterator<E>`	`descendingIterator()` Returns an iterator over the elements in this set, in descending order.
`AddressTrieSet<E>`	`descendingSet()` Returns a reverse order view of the elements contained in this set.
`boolean`	`elementContains(E addr)` Returns true if a subnet or address in the set contains the given subnet or address.
`AddressTrieSet<E>`	`elementsContainedBy(E addr)` Returns a subset consisting of those addresses in the set contained by the given address.
`AddressTrieSet<E>`	`elementsContaining(E addr)` Returns a subset consisting of those addresses in the set that contain the given address.
`boolean`	`equals(Object o)` Compares the specified object with this set for equality.
`E`	`first()` Returns the first (lowest) element currently in this set.
`E`	`floor(E e)` Returns the greatest element in this set less than or equal to the given element, or `null` if there is no such element.
`AddressTrieSet.Range<E>`	`getRange()` Returns the range if this set has a restricted range, see `hasRestrictedRange()`.
`int`	`hashCode()` Returns the hash code value for this set.
`boolean`	`hasRestrictedRange()` Returns whether this set is the result of a call to `headSet(Address)`, `tailSet(Address)`, `subSet(Address, Address)` or any of the other six methods with the same names.
`AddressTrieSet<E>`	`headSet(E toElement)` Returns a view of the portion of this set whose elements are strictly less than `toElement`.
`AddressTrieSet<E>`	`headSet(E toElement, boolean inclusive)` Returns a view of the portion of this set whose elements are less than (or equal to, if `inclusive` is true) `toElement`.
`E`	`higher(E e)` Returns the least element in this set strictly greater than the given element, or `null` if there is no such element.
`boolean`	`isEmpty()` Returns `true` if this collection contains no elements.
`Iterator<E>`	`iterator()` Returns an iterator over the elements contained in this collection.
`E`	`last()` Returns the last (highest) element currently in this set.
`E`	`longestPrefixMatch(E addr)` Returns the element with the longest prefix match with the given address.
`E`	`lower(E e)` Returns the greatest element in this set strictly less than the given element, or `null` if there is no such element.
`E`	`pollFirst()` Retrieves and removes the first (lowest) element, or returns `null` if this set is empty.
`E`	`pollLast()` Retrieves and removes the last (highest) element, or returns `null` if this set is empty.
`boolean`	`remove(Object o)` Removes a single instance of the specified element from this collection, if it is present (optional operation).
`boolean`	`removeAll(Collection<?> collection)` Removes from this set all of its elements that are contained in the specified collection (optional operation).
`int`	`size()` Returns the number of elements in this set.
`Spliterator<E>`	`spliterator()` Creates a `Spliterator` over the elements in this sorted set.
`AddressTrieSet<E>`	`subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)` Returns a view of the portion of this set whose elements range from `fromElement` to `toElement`.
`AddressTrieSet<E>`	`subSet(E fromElement, E toElement)` Returns a view of the portion of this set whose elements range from `fromElement`, inclusive, to `toElement`, exclusive.
`AddressTrieSet<E>`	`tailSet(E fromElement)` Returns a view of the portion of this set whose elements are greater than or equal to `fromElement`.
`AddressTrieSet<E>`	`tailSet(E fromElement, boolean inclusive)` Returns a view of the portion of this set whose elements are greater than (or equal to, if `inclusive` is true) `fromElement`.
`String`	`toTrieString()`

Methods inherited from class java.util.AbstractCollection
addAll, containsAll, retainAll, toArray, toArray, toString

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

Methods inherited from interface java.util.Set
addAll, containsAll, retainAll, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - AddressTrieSet
```
public AddressTrieSet(AddressTrie<E> trie)
```
  - AddressTrieSet
```
public AddressTrieSet(AddressTrie<E> trie,
                      Collection<? extends E> collection)
```
- Method Detail
  - descendingSet
```
public AddressTrieSet<E> descendingSet()
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a reverse order view of the elements contained in this set. The descending set is backed by this set, so changes to the set are reflected in the descending set, and vice-versa. If either set is modified while an iteration over either set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined.
    The returned set has an ordering equivalent to Collections.reverseOrder(comparator()). The expression s.descendingSet().descendingSet() returns a view of s essentially equivalent to s.
    
    Specified by:
    
    descendingSet in interface NavigableSet<E extends Address>
    
    Returns:
    
    a reverse order view of this set
  - asTrie
```
public AddressTrie<E> asTrie()
```
    Returns a trie representing this set.
    If this set has a restricted range, hasRestrictedRange(), this generates a new trie for the set with only the nodes pertaining to the subset. Otherwise this returns the backing trie for this set.
    When a new trie is generated, the original backing trie for this set 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 set has the reverse ordering.
  - hasRestrictedRange
```
public boolean hasRestrictedRange()
```
    Returns whether this set is the result of a call to headSet(Address), tailSet(Address), subSet(Address, Address) or any of the other six methods with the same names.
    
    Returns:
  - getRange
```
public AddressTrieSet.Range<E> getRange()
```
    Returns the range if this set has a restricted range, see hasRestrictedRange(). Otherwise returns null.
    
    Returns:
  - size
```
public int size()
```
    Returns the number of elements in this set. This is a constant time operation, unless the set has a restricted range, see hasRestrictedRange(), in which case it is a linear time operation proportional to the number of elements.
    
    Specified by:
    
    size in interface Collection<E extends Address>
    
    Specified by:
    
    size in interface Set<E extends Address>
    
    Specified by:
    
    size in class AbstractCollection<E extends Address>
    
    Returns:
    
    the number of elements in this set
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from class: java.util.AbstractCollection
    
    Returns true if this collection contains no elements.
    This implementation returns size() == 0.
    
    Specified by:
    
    isEmpty in interface Collection<E extends Address>
    
    Specified by:
    
    isEmpty in interface Set<E extends Address>
    
    Overrides:
    
    isEmpty in class AbstractCollection<E extends Address>
    
    Returns:
    
    true if this collection contains no elements
  - contains
```
public boolean contains(Object o)
```
    Description copied from class: java.util.AbstractCollection
    
    Returns true if this collection contains the specified element. More formally, returns true if and only if this collection contains at least one element e such that (o==null ? e==null : o.equals(e)).
    This implementation iterates over the elements in the collection, checking each element in turn for equality with the specified element.
    
    Specified by:
    
    contains in interface Collection<E extends Address>
    
    Specified by:
    
    contains in interface Set<E extends Address>
    
    Overrides:
    
    contains in class AbstractCollection<E extends Address>
    
    Parameters:
    
    o - element whose presence in this collection is to be tested
    
    Returns:
    
    true if this collection contains the specified element
  - add
```
public boolean add(E e)
```
    Adds the given single address or prefix block subnet to this set.
    If the given address is not a single address nor prefix block, then this method throws IllegalArgumentException.
    See AddressTrie
    
    Specified by:
    
    add in interface Collection<E extends Address>
    
    Specified by:
    
    add in interface Set<E extends Address>
    
    Overrides:
    
    add in class AbstractCollection<E extends Address>
    
    Parameters:
    
    e - element whose presence in this collection is to be ensured
    
    Returns:
    
    true if this collection changed as a result of the call
  - remove
```
public boolean remove(Object o)
```
    Description copied from class: java.util.AbstractCollection
    
    Removes a single instance of the specified element from this collection, if it is present (optional operation). More formally, removes an element e such that (o==null ? e==null : o.equals(e)), if this collection contains one or more such elements. Returns true if this collection contained the specified element (or equivalently, if this collection changed as a result of the call).
    This implementation iterates over the collection looking for the specified element. If it finds the element, it removes the element from the collection using the iterator's remove method.
    Note that this implementation throws an UnsupportedOperationException if the iterator returned by this collection's iterator method does not implement the remove method and this collection contains the specified object.
    
    Specified by:
    
    remove in interface Collection<E extends Address>
    
    Specified by:
    
    remove in interface Set<E extends Address>
    
    Overrides:
    
    remove in class AbstractCollection<E extends Address>
    
    Parameters:
    
    o - element to be removed from this collection, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - clear
```
public void clear()
```
    Description copied from class: java.util.AbstractCollection
    
    Removes all of the elements from this collection (optional operation). The collection will be empty after this method returns.
    This implementation iterates over this collection, removing each element using the Iterator.remove operation. Most implementations will probably choose to override this method for efficiency.
    Note that this implementation will throw an UnsupportedOperationException if the iterator returned by this collection's iterator method does not implement the remove method and this collection is non-empty.
    
    Specified by:
    
    clear in interface Collection<E extends Address>
    
    Specified by:
    
    clear in interface Set<E extends Address>
    
    Overrides:
    
    clear in class AbstractCollection<E extends Address>
  - hashCode
```
public int hashCode()
```
    Description copied from class: java.util.AbstractSet
    
    Returns the hash code value for this set. The hash code of a set is defined to be the sum of the hash codes of the elements in the set, where the hash code of a null element is defined to be zero. This ensures that s1.equals(s2) implies that s1.hashCode()==s2.hashCode() for any two sets s1 and s2, as required by the general contract of Object.hashCode().
    This implementation iterates over the set, calling the hashCode method on each element in the set, and adding up the results.
    
    Specified by:
    
    hashCode in interface Collection<E extends Address>
    
    Specified by:
    
    hashCode in interface Set<E extends Address>
    
    Overrides:
    
    hashCode in class AbstractSet<E extends Address>
    
    Returns:
    
    the hash code value for this set
    
    See Also:
    
    Object.equals(Object), Set.equals(Object)
  - equals
```
public boolean equals(Object o)
```
    Description copied from class: java.util.AbstractSet
    
    Compares the specified object with this set for equality. Returns true if the given object is also a set, the two sets have the same size, and every member of the given set is contained in this set. This ensures that the equals method works properly across different implementations of the Set interface.
    This implementation first checks if the specified object is this set; if so it returns true. Then, it checks if the specified object is a set whose size is identical to the size of this set; if not, it returns false. If so, it returns containsAll((Collection) o).
    
    Specified by:
    
    equals in interface Collection<E extends Address>
    
    Specified by:
    
    equals in interface Set<E extends Address>
    
    Overrides:
    
    equals in class AbstractSet<E extends Address>
    
    Parameters:
    
    o - object to be compared for equality with this set
    
    Returns:
    
    true if the specified object is equal to this set
    
    See Also:
    
    Object.hashCode(), HashMap
  - clone
```
public AddressTrieSet<E> clone()
```
    Clones the set along with the backing trie. If the set had a restricted range, the clone does not.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a clone of this instance.
    
    See Also:
    
    Cloneable
  - removeAll
```
public boolean removeAll(Collection<?> collection)
```
    Description copied from class: java.util.AbstractSet
    
    Removes from this set all of its elements that are contained in the specified collection (optional operation). If the specified collection is also a set, this operation effectively modifies this set so that its value is the asymmetric set difference of the two sets.
    This implementation determines which is the smaller of this set and the specified collection, by invoking the size method on each. If this set has fewer elements, then the implementation iterates over this set, checking each element returned by the iterator in turn to see if it is contained in the specified collection. If it is so contained, it is removed from this set with the iterator's remove method. If the specified collection has fewer elements, then the implementation iterates over the specified collection, removing from this set each element returned by the iterator, using this set's remove method.
    Note that this implementation will throw an UnsupportedOperationException if the iterator returned by the iterator method does not implement the remove method.
    
    Specified by:
    
    removeAll in interface Collection<E extends Address>
    
    Specified by:
    
    removeAll in interface Set<E extends Address>
    
    Overrides:
    
    removeAll in class AbstractSet<E extends Address>
    
    Parameters:
    
    collection - collection containing elements to be removed from this set
    
    Returns:
    
    true if this set changed as a result of the call
    
    See Also:
    
    AbstractCollection.remove(Object), AbstractCollection.contains(Object)
  - iterator
```
public Iterator<E> iterator()
```
    Description copied from class: java.util.AbstractCollection
    
    Returns an iterator over the elements contained in this collection.
    
    Specified by:
    
    iterator in interface Iterable<E extends Address>
    
    Specified by:
    
    iterator in interface Collection<E extends Address>
    
    Specified by:
    
    iterator in interface NavigableSet<E extends Address>
    
    Specified by:
    
    iterator in interface Set<E extends Address>
    
    Specified by:
    
    iterator in class AbstractCollection<E extends Address>
    
    Returns:
    
    an iterator over the elements contained in this collection
  - descendingIterator
```
public Iterator<E> descendingIterator()
```
    Description copied from interface: java.util.NavigableSet
    
    Returns an iterator over the elements in this set, in descending order. Equivalent in effect to descendingSet().iterator().
    
    Specified by:
    
    descendingIterator in interface NavigableSet<E extends Address>
    
    Returns:
    
    an iterator over the elements in this set, in descending order
  - containingFirstIterator
```
public Iterator<E> containingFirstIterator()
```
    Returns an iterator that visits containing subnet blocks before their contained addresses and subnet blocks.
  - containedFirstIterator
```
public Iterator<E> containedFirstIterator()
```
    Returns an iterator that visits contained addresses and subnet blocks before their containing subnet blocks.
  - spliterator
```
public Spliterator<E> spliterator()
```
    Description copied from interface: java.util.SortedSet
    
    Creates a Spliterator over the elements in this sorted set.
    The Spliterator reports Spliterator.DISTINCT, Spliterator.SORTED and Spliterator.ORDERED. Implementations should document the reporting of additional characteristic values.
    The spliterator's comparator (see Spliterator.getComparator()) must be null if the sorted set's comparator (see SortedSet.comparator()) is null. Otherwise, the spliterator's comparator must be the same as or impose the same total ordering as the sorted set's comparator.
    
    Specified by:
    
    spliterator in interface Iterable<E extends Address>
    
    Specified by:
    
    spliterator in interface Collection<E extends Address>
    
    Specified by:
    
    spliterator in interface Set<E extends Address>
    
    Specified by:
    
    spliterator in interface SortedSet<E extends Address>
    
    Returns:
    
    a Spliterator over the elements in this sorted set
  - comparator
```
public Comparator<E> comparator()
```
    Description copied from interface: java.util.SortedSet
    
    Returns the comparator used to order the elements in this set, or null if this set uses the natural ordering of its elements.
    
    Specified by:
    
    comparator in interface SortedSet<E extends Address>
    
    Returns:
    
    the comparator used to order the elements in this set, or null if this set uses the natural ordering of its elements
  - blockSizeIterator
```
public Iterator<E> blockSizeIterator()
```
    Iterates from largest prefix blocks to smallest to individual addresses. Blocks of equal size are iterated in set order.
    
    Returns:
  - subSet
```
public AddressTrieSet<E> subSet(E fromElement,
                                E toElement)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive. (If fromElement and toElement are equal, the returned set is empty.) The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to subSet(fromElement, true, toElement, false).
    
    Specified by:
    
    subSet in interface NavigableSet<E extends Address>
    
    Specified by:
    
    subSet in interface SortedSet<E extends Address>
    
    Parameters:
    
    fromElement - low endpoint (inclusive) of the returned set
    
    toElement - high endpoint (exclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive
  - subSet
```
public AddressTrieSet<E> subSet(E fromElement,
                                boolean fromInclusive,
                                E toElement,
                                boolean toInclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements range from fromElement to toElement. If fromElement and toElement are equal, the returned set is empty unless fromInclusive and toInclusive are both true. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    subSet in interface NavigableSet<E extends Address>
    
    Parameters:
    
    fromElement - low endpoint of the returned set
    
    fromInclusive - true if the low endpoint is to be included in the returned view
    
    toElement - high endpoint of the returned set
    
    toInclusive - true if the high endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive
  - headSet
```
public AddressTrieSet<E> headSet(E toElement)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are strictly less than toElement. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to headSet(toElement, false).
    
    Specified by:
    
    headSet in interface NavigableSet<E extends Address>
    
    Specified by:
    
    headSet in interface SortedSet<E extends Address>
    
    Parameters:
    
    toElement - high endpoint (exclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements are strictly less than toElement
  - headSet
```
public AddressTrieSet<E> headSet(E toElement,
                                 boolean inclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    headSet in interface NavigableSet<E extends Address>
    
    Parameters:
    
    toElement - high endpoint of the returned set
    
    inclusive - true if the high endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement
  - tailSet
```
public AddressTrieSet<E> tailSet(E fromElement)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are greater than or equal to fromElement. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to tailSet(fromElement, true).
    
    Specified by:
    
    tailSet in interface NavigableSet<E extends Address>
    
    Specified by:
    
    tailSet in interface SortedSet<E extends Address>
    
    Parameters:
    
    fromElement - low endpoint (inclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements are greater than or equal to fromElement
  - tailSet
```
public AddressTrieSet<E> tailSet(E fromElement,
                                 boolean inclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are greater than (or equal to, if inclusive is true) fromElement. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    tailSet in interface NavigableSet<E extends Address>
    
    Parameters:
    
    fromElement - low endpoint of the returned set
    
    inclusive - true if the low endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements are greater than or equal to fromElement
  - first
```
public E first()
```
    Description copied from interface: java.util.SortedSet
    
    Returns the first (lowest) element currently in this set.
    
    Specified by:
    
    first in interface SortedSet<E extends Address>
    
    Returns:
    
    the first (lowest) element currently in this set
  - last
```
public E last()
```
    Description copied from interface: java.util.SortedSet
    
    Returns the last (highest) element currently in this set.
    
    Specified by:
    
    last in interface SortedSet<E extends Address>
    
    Returns:
    
    the last (highest) element currently in this set
  - lower
```
public E lower(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
    
    Specified by:
    
    lower in interface NavigableSet<E extends Address>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the greatest element less than e, or null if there is no such element
  - floor
```
public E floor(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.
    
    Specified by:
    
    floor in interface NavigableSet<E extends Address>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the greatest element less than or equal to e, or null if there is no such element
  - ceiling
```
public E ceiling(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the least element in this set greater than or equal to the given element, or null if there is no such element.
    
    Specified by:
    
    ceiling in interface NavigableSet<E extends Address>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the least element greater than or equal to e, or null if there is no such element
  - higher
```
public E higher(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the least element in this set strictly greater than the given element, or null if there is no such element.
    
    Specified by:
    
    higher in interface NavigableSet<E extends Address>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the least element greater than e, or null if there is no such element
  - pollFirst
```
public E pollFirst()
```
    Description copied from interface: java.util.NavigableSet
    
    Retrieves and removes the first (lowest) element, or returns null if this set is empty.
    
    Specified by:
    
    pollFirst in interface NavigableSet<E extends Address>
    
    Returns:
    
    the first element, or null if this set is empty
  - pollLast
```
public E pollLast()
```
    Description copied from interface: java.util.NavigableSet
    
    Retrieves and removes the last (highest) element, or returns null if this set is empty.
    
    Specified by:
    
    pollLast in interface NavigableSet<E extends Address>
    
    Returns:
    
    the last element, or null if this set is empty
  - toTrieString
```
public String toTrieString()
```
  - elementsContainedBy
```
public AddressTrieSet<E> elementsContainedBy(E addr)
```
    Returns a subset consisting of those addresses in the set contained by the given address. The subset will have a restricted range matching the range of the given subnet or address.
    If the subset would be the same size as this set, then this set is returned. The subset will the same backing trie as this set.
    
    Parameters:
    
    addr -
    
    Returns:
  - elementsContaining
```
public AddressTrieSet<E> elementsContaining(E addr)
```
    Returns a subset consisting of those addresses in the set that contain the given address. The subset will have the same restricted range (if any) as this set.
    If the subset would be the same size as this set, then this set is returned. Otherwise, the subset is backed by a new trie.
    
    Parameters:
    
    addr -
    
    Returns:
  - elementContains
```
public boolean elementContains(E addr)
```
    Returns true if a subnet or address in the set contains the given subnet or address.
    
    Parameters:
    
    addr -
    
    Returns:
  - longestPrefixMatch
```
public E longestPrefixMatch(E addr)
```
    Returns the element with the longest prefix match with the given address.
    
    Parameters:
    
    addr -
    
    Returns:

Class AddressTrieSet<E extends Address>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Set

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Constructor Detail

AddressTrieSet

AddressTrieSet

Method Detail

descendingSet

asTrie

hasRestrictedRange

getRange

size

isEmpty

contains

add

remove

clear

hashCode

equals

clone

removeAll

iterator

descendingIterator

containingFirstIterator

containedFirstIterator

spliterator

comparator

blockSizeIterator

subSet

subSet

headSet

headSet

tailSet

tailSet

first

last

lower

floor

ceiling

higher

pollFirst

pollLast

toTrieString

elementsContainedBy

elementsContaining

elementContains

longestPrefixMatch