IPAddressSegmentSeries (IPAddress javadoc by seancfoley)

All Superinterfaces:

AddressComponent, AddressComponentRange, AddressDivisionSeries, AddressItem, AddressItemRange, AddressSegmentSeries, AddressStringDivisionSeries, Comparable<AddressItem>, IPAddressDivisionSeries, IPAddressStringDivisionSeries, Serializable

All Known Implementing Classes:

IPAddress, IPAddressSection, IPv4Address, IPv4AddressSection, IPv6Address, IPv6AddressSection
```
public interface IPAddressSegmentSeries
extends IPAddressDivisionSeries, AddressSegmentSeries
```
Represents a series of IP address segments.
Provides methods relevant to IP addresses and IP address sections in addition to the more general methods pertaining to address and address sections in AddressSegmentSeries.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`IPAddressSegmentSeries`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`IPAddressSegmentSeries`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`IPAddressSegmentSeries`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`IPAddressSegmentSeries`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`IPAddressSegmentSeries`	`applyPrefixLength(int networkPrefixLength)` Deprecated.
`IPAddressSegmentSeries`	`assignMinPrefixForBlock()` Returns the equivalent address series with the smallest CIDR prefix possible (largest network), such that the range of values of this address includes the subnet prefix block for that prefix.
`IPAddressSegmentSeries`	`assignPrefixForSingleBlock()` Returns the equivalent CIDR address series with a prefix length for which the subnet block for that prefix matches the range of values in this series.
`Iterator<? extends IPAddressSegmentSeries>`	`blockIterator(int segmentCount)` Iterates through series that can be obtained by iterating through all the upper segments up to the given segment count.
`AddressComponentSpliterator<? extends IPAddressSegmentSeries>`	`blockSpliterator(int segmentCount)` Partitions and traverses through the individual sequential blocks created from each of the individual values up to the given segment count.
`Stream<? extends IPAddressSegmentSeries>`	`blockStream(int segmentCount)` Returns a sequential stream of the individual blocks created from each of the individual values up to the given segment count.
`IPAddressSegmentSeries`	`coverWithPrefixBlock()` Returns the minimal-size prefix block that covers all the values in this series.
`IPAddressSegmentSeries`	`getHostMask()` Returns the host mask associated with the CIDR network prefix length of this series.
`IPAddressSection`	`getHostSection()` Returns the host section of the series.
`IPAddressSection`	`getHostSection(int networkPrefixLength)` Returns the host section of the address as indicated by the network prefix length provided.
`IPAddress.IPVersion`	`getIPVersion()` Returns the version of this segment series
`Iterable<? extends IPAddressSegmentSeries>`	`getIterable()` Useful for using an instance in a "for-each loop".
`IPAddressSegmentSeries`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`IPAddressSegmentSeries`	`getLowerNonZeroHost()` Similar to `getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`IPAddressNetwork<?,?,?,?,?>`	`getNetwork()` Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`IPAddressSegmentSeries`	`getNetworkMask()` Returns the network mask associated with the CIDR network prefix length of this series.
`IPAddressSection`	`getNetworkSection()` Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
`IPAddressSection`	`getNetworkSection(int networkPrefixLength)` Returns the network section of the series.
`IPAddressSection`	`getNetworkSection(int networkPrefixLength, boolean withPrefixLength)` Returns the network section of the series.
`BigInteger`	`getNonZeroHostCount()` Gets the count of single value series that this series may represent, but excluding series whose host is zero.
`static Comparator<? super IPAddressSegmentSeries>`	`getPrefixLenComparator()` Returns a comparator to sort series by prefix length.
`IPAddressSection`	`getSection()` Gets the subsection from the series that comprises all segments
`IPAddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index The first segment is at index 0.
`IPAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex The first segment is at index 0.
`IPAddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`IPAddressSegment[]`	`getSegments()` Returns the segments of this series of segments as an array.
`BigInteger`	`getSequentialBlockCount()` provides the count of elements from the `sequentialBlockIterator()`, the minimal number of sequential sub-series that comprise this series
`IPAddressSegmentSeries`	`getUpper()` If this represents a series with ranging values, returns a series representing the upper values of the range.
`boolean`	`includesMaxHost()` Returns whether the series has a host of all ones.
`boolean`	`includesMaxHost(int prefixLength)` Returns whether all bits past the given prefix length are all ones.
`boolean`	`includesZeroHost()` Returns whether the series has a host of zero.
`boolean`	`includesZeroHost(int prefixLength)` Returns whether all bits past the given prefix length are zero.
`IPAddressSegmentSeries`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
`IPAddressSegmentSeries`	`incrementBoundary(long increment)` If the given increment is positive, adds the value to the upper series (`AddressSegmentSeries.getUpper()`) in the subnet range to produce a new series.
`Iterator<? extends IPAddressSegmentSeries>`	`iterator()` Iterates through the individual address components.
`Iterator<? extends IPAddressSegmentSeries>`	`nonZeroHostIterator()` Similar to the iterator, but series with a host of zero are skipped.
`Iterator<? extends IPAddressSegmentSeries>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`AddressComponentSpliterator<? extends IPAddressSegmentSeries>`	`prefixBlockSpliterator()` Partitions and traverses through the individual prefix blocks for the prefix length of this series.
`Stream<? extends IPAddressSegmentSeries>`	`prefixBlockStream()` Returns a sequential stream of the individual prefix blocks for the prefix length of this series.
`Iterator<? extends IPAddressSegmentSeries>`	`prefixIterator()` Iterates through the individual prefixes.
`AddressComponentSpliterator<? extends IPAddressSegmentSeries>`	`prefixSpliterator()` Partitions and traverses through the individual prefixes for the prefix length of this series.
`Stream<? extends IPAddressSegmentSeries>`	`prefixStream()` Returns a sequential stream of the individual prefixes for the prefix length of this series.
`IPAddressSegmentSeries`	`removePrefixLength()` Deprecated.
`IPAddressSegmentSeries`	`removePrefixLength(boolean zeroed)` Deprecated.
`IPAddressSegmentSeries`	`reverseBits(boolean perByte)` Returns a new series which has the bits reversed.
`IPAddressSegmentSeries`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`IPAddressSegmentSeries`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`IPAddressSegmentSeries`	`reverseSegments()` Returns a new segment series with the segments reversed.
`Iterator<? extends IPAddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`Iterator<? extends IPAddressSegment[]>`	`segmentsNonZeroHostIterator()` Similar to the segments iterator, but series with a host of zero are skipped.
`AddressComponentRangeSpliterator<? extends IPAddressSegmentSeries,? extends IPAddressSegment[]>`	`segmentsSpliterator()` Partitions and traverses through the individual segment arrays.
`Stream<? extends IPAddressSegment[]>`	`segmentsStream()` Returns a sequential stream of the individual segment arrays.
`Iterator<? extends IPAddressSegmentSeries>`	`sequentialBlockIterator()` Iterates through the sequential series that make up this series.
`AddressComponentSpliterator<? extends IPAddressSegmentSeries>`	`sequentialBlockSpliterator()` Partitions and traverses through the individual sequential blocks.
`Stream<? extends IPAddressSegmentSeries>`	`sequentialBlockStream()` Returns a sequential stream of the individual sequential blocks.
`IPAddressSegmentSeries`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`IPAddressSegmentSeries`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`IPAddressSegmentSeries[]`	`spanWithPrefixBlocks()` Produces an array of prefix blocks that spans the same set of values.
`IPAddressSegmentSeries[]`	`spanWithSequentialBlocks()` Produces an array of blocks that are sequential that cover the same set of values.
`AddressComponentSpliterator<? extends IPAddressSegmentSeries>`	`spliterator()` Partitions and traverses through the individual address components.
`Stream<? extends IPAddressSegmentSeries>`	`stream()` Returns a sequential stream of the individual address components.
`String`	`toBinaryString()` Writes this IP address segment series as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two binary values.
`String`	`toCanonicalWildcardString()` This produces a string similar to the canonical string and avoids the CIDR prefix.
`String`	`toCompressedWildcardString()` This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
`String`	`toFullString()` This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments.
`IPAddressSegmentSeries`	`toMaxHost()` Returns the segment series with a host of all ones.
`IPAddressSegmentSeries`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`String`	`toNormalizedString(IPAddressSection.IPStringOptions stringOptions)` Creates a customized string from this series.
`String`	`toNormalizedWildcardString()` This produces a string similar to the normalized string and avoids the CIDR prefix.
`String`	`toOctalString(boolean with0Prefix)` Writes this IP address segment series as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix.
`IPAddressSegmentSeries`	`toPrefixBlock()` If this series has a prefix length, returns the subnet block for that prefix.
`IPAddressSegmentSeries`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`String`	`toPrefixLengthString()` Returns a string with a CIDR prefix length if this section has a network prefix length.
`String`	`toReverseDNSLookupString()` Generates the reverse DNS lookup string For 8.255.4.4 it is 4.4.255.8.in-addr.arpa For 2001:db8::567:89ab it is b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa
`String`	`toSegmentedBinaryString()` Writes this IP address segment series as a segments of binary values preceded by the "0b" prefix.
`String`	`toSQLWildcardString()` This is the same as the string from toNormalizedWildcardString except that it uses `Address.SEGMENT_SQL_WILDCARD` instead of `Address.SEGMENT_WILDCARD` and also uses `Address.SEGMENT_SQL_SINGLE_WILDCARD`
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions options)`
`String`	`toSubnetString()` Produces a consistent subnet string.
`IPAddressSegmentSeries`	`toZeroHost()` Returns the segment series with a host of zero, the host being the bits following the prefix length.
`IPAddressSegmentSeries`	`toZeroHost(int prefixLength)` Produces the series with host values of 0 for the given prefix length.
`IPAddressSegmentSeries`	`toZeroNetwork()` Returns the segment series with a network of zero, the network being the bits within the prefix length.
`IPAddressSegmentSeries`	`withoutPrefixLength()` Provides the same address with no prefix.

Methods inherited from interface inet.ipaddr.format.IPAddressDivisionSeries
getDivision, getNetworkPrefixLength

Methods inherited from interface inet.ipaddr.format.string.IPAddressStringDivisionSeries
getPrefixLength, isPrefixBlock, isPrefixed

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getBitsPerSegment, getBytesPerSegment, getMaxSegmentValue, getSegmentCount, getSegments, getSegments, getSegmentStrings, isOneBit, testBit, toCanonicalString, toCompressedString

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getBitCount, getBlockCount, getCount, getDivisionStrings, getPrefixCount, getPrefixCount, getPrefixLength, getSequentialBlockIndex, isMore, isPrefixBlock, isPrefixed, isSequential, isSinglePrefixBlock

Methods inherited from interface inet.ipaddr.format.string.AddressStringDivisionSeries
getDivisionCount

Methods inherited from interface inet.ipaddr.AddressComponent
toHexString, toNormalizedString

Methods inherited from interface inet.ipaddr.format.AddressComponentRange
stream, stream

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBitsForCount, getBlockSize, getByteCount, getBytes, getBytes, getBytes, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, includesMax, includesZero, isFullRange, isMax, isMultiple, isZero

- Method Detail
  - getPrefixLenComparator
```
static Comparator<? super IPAddressSegmentSeries> getPrefixLenComparator()
```
    Returns a comparator to sort series by prefix length.
    
    Returns:
  - getIPVersion
```
IPAddress.IPVersion getIPVersion()
```
    Returns the version of this segment series
    
    Returns:
  - assignMinPrefixForBlock
```
IPAddressSegmentSeries assignMinPrefixForBlock()
```
    Returns the equivalent address series with the smallest CIDR prefix possible (largest network), such that the range of values of this address includes the subnet prefix block for that prefix.
    
    Returns:
    
    See Also:
    
    toPrefixBlock(), assignPrefixForSingleBlock()
  - assignPrefixForSingleBlock
```
IPAddressSegmentSeries assignPrefixForSingleBlock()
```
    Returns the equivalent CIDR address series with a prefix length for which the subnet block for that prefix matches the range of values in this series. In short, the returned series is a single block of address segment series. Another way of looking at it: if the range matches the range associated with some prefix length, then it returns the address series with that prefix length.
    If no such prefix length exists, returns null.
    If this address represents just a single address, "this" is returned.
    The methods assignMinPrefixForBlock(), assignPrefixForSingleBlock() can be compared as follows.
    assignMinPrefixForBlock() finds the smallest prefix length possible for this subnet and returns that subnet.
    assignPrefixForSingleBlock() finds the smallest prefix length possible for this subnet that results in just a single prefix and returns that subnet.
    
    For example, given the address 1-2.2.3.* /16
    assignMinPrefixForBlock() returns 1-2.2.3.* /24 if the prefix configuration is the default or is not ALL_PREFIXES_ARE_SUBNETS, otherwise 1-2.2.*.* /16, in order to return the subnet with the smallest prefix length
    assignPrefixForSingleBlock() returns null because any prefix length will end up with at least two prefixes due to the first segment spanning two values: 1-2.
    For another example, for the address 1.2.*.* /16 or the address 1.2.*.* both methods return 1.2.*.* /16.
    
    Returns:
    
    See Also:
    
    toPrefixBlock(), assignMinPrefixForBlock()
  - coverWithPrefixBlock
```
IPAddressSegmentSeries coverWithPrefixBlock()
```
    Returns the minimal-size prefix block that covers all the values in this series. The resulting block will have a larger series count than this, unless this series is already a prefix block.
  - spanWithPrefixBlocks
```
IPAddressSegmentSeries[] spanWithPrefixBlocks()
```
    Produces an array of prefix blocks that spans the same set of values.
  - spanWithSequentialBlocks
```
IPAddressSegmentSeries[] spanWithSequentialBlocks()
```
    Produces an array of blocks that are sequential that cover the same set of values. This array can be shorter than that produced by spanWithPrefixBlocks() and is never longer.
  - toPrefixBlock
```
IPAddressSegmentSeries toPrefixBlock()
```
    If this series has a prefix length, returns the subnet block for that prefix. If this series has no prefix length, this series is returned.
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Returns:
    
    the subnet block for the prefix length
  - toPrefixBlock
```
IPAddressSegmentSeries toPrefixBlock(int networkPrefixLength)
                              throws PrefixLenException
```
    Returns the segment series of the same length that spans all hosts. The network prefix length will be the one provided, and the network values will match the same of this series.
    
    Parameters:
    
    networkPrefixLength -
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getHostMask
```
IPAddressSegmentSeries getHostMask()
```
    Returns the host mask associated with the CIDR network prefix length of this series. If this series has no prefix length, then the whole series is considered a host and the all ones host mask is returned.
    
    Returns:
  - getNetworkMask
```
IPAddressSegmentSeries getNetworkMask()
```
    Returns the network mask associated with the CIDR network prefix length of this series. If this series has no prefix length, then the whole series is considered network and the all ones network mask is returned.
    
    Returns:
  - getHostSection
```
IPAddressSection getHostSection()
```
    Returns the host section of the series. The returned section will have only as many segments as needed as determined by the existing CIDR network prefix length. If this series has no CIDR prefix length, the returned host section will be the full section associated with a prefix length of 0.
    
    Returns:
  - getHostSection
```
IPAddressSection getHostSection(int networkPrefixLength)
```
    Returns the host section of the address as indicated by the network prefix length provided. The returned section will have only as many segments as needed to hold the host as indicated by the provided network prefix length.
    
    Parameters:
    
    networkPrefixLength -
    
    Returns:
  - getNetworkSection
```
IPAddressSection getNetworkSection()
```
    Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
    
    Returns:
  - getNetworkSection
```
IPAddressSection getNetworkSection(int networkPrefixLength)
```
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. It will have networkPrefixLength as its associated prefix length, unless this address already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Parameters:
    
    networkPrefixLength -
    
    Returns:
  - getNetworkSection
```
IPAddressSection getNetworkSection(int networkPrefixLength,
                                   boolean withPrefixLength)
```
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. If withPrefixLength is true, it will have networkPrefixLength as its associated prefix length, unless this series already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Parameters:
    
    networkPrefixLength -
    
    withPrefixLength - whether the resulting section will have networkPrefixLength as the associated prefix length or not
    
    Returns:
  - toFullString
```
String toFullString()
```
    This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments.
  - toPrefixLengthString
```
String toPrefixLengthString()
```
    Returns a string with a CIDR prefix length if this section has a network prefix length. For IPv6, the host section will be compressed with ::, for IPv4 the host section will be zeros.
    
    Returns:
  - toSubnetString
```
String toSubnetString()
```
    Produces a consistent subnet string. In the case of IPv4, this means that wildcards are used instead of a network prefix. In the case of IPv6, a prefix will be used and the host section will be compressed with ::.
  - toNormalizedWildcardString
```
String toNormalizedWildcardString()
```
    This produces a string similar to the normalized string and avoids the CIDR prefix. CIDR addresses will be shown with wildcards and ranges instead of using the CIDR prefix notation.
  - toCanonicalWildcardString
```
String toCanonicalWildcardString()
```
    This produces a string similar to the canonical string and avoids the CIDR prefix. Addresses with a network prefix length will be shown with wildcards and ranges instead of using the CIDR prefix length notation. IPv6 addresses will be compressed according to the canonical representation.
  - toCompressedWildcardString
```
String toCompressedWildcardString()
```
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
  - toSQLWildcardString
```
String toSQLWildcardString()
```
    This is the same as the string from toNormalizedWildcardString except that it uses Address.SEGMENT_SQL_WILDCARD instead of Address.SEGMENT_WILDCARD and also uses Address.SEGMENT_SQL_SINGLE_WILDCARD
  - toReverseDNSLookupString
```
String toReverseDNSLookupString()
```
    Generates the reverse DNS lookup string For 8.255.4.4 it is 4.4.255.8.in-addr.arpa For 2001:db8::567:89ab it is b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this address is a subnet
  - toBinaryString
```
String toBinaryString()
               throws IncompatibleAddressException
```
    Writes this IP address segment series as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two binary values.
    
    Throws:
    
    IncompatibleAddressException
  - toSegmentedBinaryString
```
String toSegmentedBinaryString()
```
    Writes this IP address segment series as a segments of binary values preceded by the "0b" prefix.
  - toOctalString
```
String toOctalString(boolean with0Prefix)
              throws IncompatibleAddressException
```
    Writes this IP address segment series as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Throws:
    
    IncompatibleAddressException
  - toStringCollection
```
IPAddressPartStringCollection toStringCollection(IPAddressSection.IPStringBuilderOptions options)
```
  - toNormalizedString
```
String toNormalizedString(IPAddressSection.IPStringOptions stringOptions)
```
    Creates a customized string from this series.
    
    Parameters:
    
    stringOptions -
    
    Returns:
  - getNetwork
```
IPAddressNetwork<?,?,?,?,?> getNetwork()
```
    Description copied from interface: AddressComponent
    
    Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressComponent
    
    Specified by:
    
    getNetwork in interface IPAddressStringDivisionSeries
    
    Returns:
  - getSection
```
IPAddressSection getSection()
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series that comprises all segments
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
IPAddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
IPAddressSection getSection(int index,
                            int endIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index and ending just before the give endIndex The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSegment
```
IPAddressSegment getSegment(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segment from this series at the given index. The first segment is at index 0. A segment is an address division, see AddressDivisionSeries.getDivision(int), the difference being that all segments in a given series are the same bit count, while divisions can have variable length.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
IPAddressSegment[] getSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segments of this series of segments as an array. This must create a new array, so for efficiency use AddressSegmentSeries.getSegment(int) and AddressSegmentSeries.getSegmentCount() instead when feasible.
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Returns:
  - getNonZeroHostCount
```
BigInteger getNonZeroHostCount()
```
    Gets the count of single value series that this series may represent, but excluding series whose host is zero. The host is determined by the CIDR prefix length, if there is one.
    If this address series has no range of values, then there is only one such address, or none if it has a zero host.
    If this has no CIDR network prefix length, then it is equivalent to AddressDivisionSeries.getCount().
    
    Returns:
  - getLowerNonZeroHost
```
IPAddressSegmentSeries getLowerNonZeroHost()
```
    Similar to getLower(), but will not return a series that has a prefix length and whose host value is zero. If this series has no prefix length, returns the same series as getLower().
    
    Returns:
    
    the lowest IP address series whose host is non-zero, or null if no such address section exists.
  - getLower
```
IPAddressSegmentSeries getLower()
```
    Description copied from interface: AddressSegmentSeries
    
    If this represents a series with ranging values, returns a series representing the lower values of the range. If this represents an series with a single value in each segment, returns this.
    
    Specified by:
    
    getLower in interface AddressComponentRange
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Returns:
  - getUpper
```
IPAddressSegmentSeries getUpper()
```
    Description copied from interface: AddressSegmentSeries
    
    If this represents a series with ranging values, returns a series representing the upper values of the range. If this represents a series with a single value in each segment, returns this.
    
    Specified by:
    
    getUpper in interface AddressComponentRange
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Returns:
  - getIterable
```
Iterable<? extends IPAddressSegmentSeries> getIterable()
```
    Description copied from interface: AddressComponentRange
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponentRange.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponentRange
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Returns:
  - iterator
```
Iterator<? extends IPAddressSegmentSeries> iterator()
```
    Description copied from interface: AddressComponentRange
    
    Iterates through the individual address components.
    An address component can represent an individual segment, address, or section, or it can represent multiple, typically a subnet of addresses or a range of segment or section values.
    Call AddressItem.isMultiple() to determine if this instance represents multiple, or AddressItem.getCount() for the count.
    
    Specified by:
    
    iterator in interface AddressComponentRange
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Returns:
  - spliterator
```
AddressComponentSpliterator<? extends IPAddressSegmentSeries> spliterator()
```
    Description copied from interface: AddressComponentRange
    
    Partitions and traverses through the individual address components.
    
    Specified by:
    
    spliterator in interface AddressComponent
    
    Specified by:
    
    spliterator in interface AddressComponentRange
    
    Specified by:
    
    spliterator in interface AddressSegmentSeries
    
    Returns:
  - stream
```
Stream<? extends IPAddressSegmentSeries> stream()
```
    Description copied from interface: AddressComponentRange
    
    Returns a sequential stream of the individual address components. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    stream in interface AddressComponentRange
    
    Specified by:
    
    stream in interface AddressSegmentSeries
    
    Returns:
  - prefixIterator
```
Iterator<? extends IPAddressSegmentSeries> prefixIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual prefixes.
    If the series has no prefix length, then this is equivalent to AddressSegmentSeries.iterator()
    
    Specified by:
    
    prefixIterator in interface AddressSegmentSeries
  - prefixSpliterator
```
AddressComponentSpliterator<? extends IPAddressSegmentSeries> prefixSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefixes for the prefix length of this series.
    
    Specified by:
    
    prefixSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixStream
```
Stream<? extends IPAddressSegmentSeries> prefixStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefixes for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixStream in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockIterator
```
Iterator<? extends IPAddressSegmentSeries> prefixBlockIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual prefix blocks.
    If the series has no prefix length, then this is equivalent to AddressSegmentSeries.iterator()
    
    Specified by:
    
    prefixBlockIterator in interface AddressSegmentSeries
  - prefixBlockSpliterator
```
AddressComponentSpliterator<? extends IPAddressSegmentSeries> prefixBlockSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefix blocks for the prefix length of this series.
    
    Specified by:
    
    prefixBlockSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockStream
```
Stream<? extends IPAddressSegmentSeries> prefixBlockStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefix blocks for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixBlockStream in interface AddressSegmentSeries
    
    Returns:
  - nonZeroHostIterator
```
Iterator<? extends IPAddressSegmentSeries> nonZeroHostIterator()
```
    Similar to the iterator, but series with a host of zero are skipped.
    
    Returns:
  - blockIterator
```
Iterator<? extends IPAddressSegmentSeries> blockIterator(int segmentCount)
```
    Iterates through series that can be obtained by iterating through all the upper segments up to the given segment count. Segments following remain the same in all iterated series.
    For instance, given the IPv4 subnet 1-2.3-4.5-6.7, given the count argument 2, it will iterate through 1.3.5-6.7, 1.4.5-6.7, 2.3.5-6.7, 2.4.5-6.7
    
    Parameters:
    
    segmentCount -
    
    Returns:
  - blockSpliterator
```
AddressComponentSpliterator<? extends IPAddressSegmentSeries> blockSpliterator(int segmentCount)
```
    Partitions and traverses through the individual sequential blocks created from each of the individual values up to the given segment count.
    
    Returns:
  - blockStream
```
Stream<? extends IPAddressSegmentSeries> blockStream(int segmentCount)
```
    Returns a sequential stream of the individual blocks created from each of the individual values up to the given segment count. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Returns:
  - sequentialBlockIterator
```
Iterator<? extends IPAddressSegmentSeries> sequentialBlockIterator()
```
    Iterates through the sequential series that make up this series. Generally this means finding the count of segments for which the segments that follow are not full range, and then using blockIterator(int) with that segment count.
    For instance, given the IPv4 subnet 1-2.3-4.5-6.7-8, it will iterate through 1.3.5.7-8, 1.3.6.7-8, 1.4.5.7-8, 1.4.6.7-8, 2.3.5.7-8, 2.3.6.7-8, 2.4.6.7-8, 2.4.6.7-8.
    Use getSequentialBlockCount() to get the count of iterated elements.
    
    Returns:
  - sequentialBlockSpliterator
```
AddressComponentSpliterator<? extends IPAddressSegmentSeries> sequentialBlockSpliterator()
```
    Partitions and traverses through the individual sequential blocks.
    
    Returns:
  - sequentialBlockStream
```
Stream<? extends IPAddressSegmentSeries> sequentialBlockStream()
```
    Returns a sequential stream of the individual sequential blocks. For a parallel stream, call BaseStream.parallel() on the returned stream.
    Use getSequentialBlockCount() to get the count of streamed elements.
    
    Returns:
  - getSequentialBlockCount
```
BigInteger getSequentialBlockCount()
```
    provides the count of elements from the sequentialBlockIterator(), the minimal number of sequential sub-series that comprise this series
    
    Returns:
  - segmentsIterator
```
Iterator<? extends IPAddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
  - segmentsSpliterator
```
AddressComponentRangeSpliterator<? extends IPAddressSegmentSeries,? extends IPAddressSegment[]> segmentsSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual segment arrays.
    
    Specified by:
    
    segmentsSpliterator in interface AddressSegmentSeries
    
    Returns:
  - segmentsStream
```
Stream<? extends IPAddressSegment[]> segmentsStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual segment arrays. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    segmentsStream in interface AddressSegmentSeries
    
    Returns:
  - segmentsNonZeroHostIterator
```
Iterator<? extends IPAddressSegment[]> segmentsNonZeroHostIterator()
```
    Similar to the segments iterator, but series with a host of zero are skipped.
    
    Returns:
  - increment
```
IPAddressSegmentSeries increment(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which it exceeds the size - 1 is added to the upper series of the range (the final iterator value).
    If the increment is negative, it is added to the lower series of the range (the first iterator value).
    If the subnet is just a single address values, the series is simply incremented by the given value, positive or negative.
    If a subnet has multiple values, a positive increment value is equivalent to the same number of values from the AddressSegmentSeries.iterator() For instance, a increment of 0 is the first value from the iterator, an increment of 1 is the second value from the iterator, and so on. A negative increment added to the subnet count is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of count - 1 is the last value from the iterator, an increment of count - 2 is the second last value, and so on.
    An increment of size count gives you the series just above the highest series of the subnet. To get the series just below the lowest series of the subnet, use the increment -1.
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Returns:
  - incrementBoundary
```
IPAddressSegmentSeries incrementBoundary(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    If the given increment is positive, adds the value to the upper series (AddressSegmentSeries.getUpper()) in the subnet range to produce a new series. If the given increment is negative, adds the value to the lower series (AddressSegmentSeries.getLower()) in the subnet range to produce a new series. If the increment is zero, returns this.
    In the case where the series is a single value, this simply returns the address produced by adding the given increment to this address series.
    
    Specified by:
    
    incrementBoundary in interface AddressSegmentSeries
    
    Returns:
  - toZeroHost
```
IPAddressSegmentSeries toZeroHost()
```
    Returns the segment series with a host of zero, the host being the bits following the prefix length. If the series has no prefix length, then it returns an all-zero series.
    The default behaviour is that the resultant series will have the same prefix length. The resultant series will not have a prefix length if AddressNetwork.getPrefixConfiguration() is AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS.
    For instance, you can get the network address for a subnet as follows: String addrStr = "1.2.3.4/16"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress networkAddress = address.toZeroHost(); //1.2.0.0
    
    Returns:
    
    See Also:
    
    toZeroNetwork()
  - toZeroHost
```
IPAddressSegmentSeries toZeroHost(int prefixLength)
```
    Produces the series with host values of 0 for the given prefix length.
    If this series has the same prefix length, then the resulting series will too, otherwise the resulting series will have no prefix length.
    This is nearly equivalent to doing the mask (bitwise conjunction) of this address series with the network mask for the given prefix length, but without the possibility of IncompatibleAddressException that can occur when applying a mask to a range of values. Instead, in this case, if the resulting series has a range of values, then the resulting series range boundaries will have host values of 0, but not necessarily the intervening values.
    For instance, you can get the network address for a subnet of prefix length 16 as follows: String addrStr = "1.2.3.4"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress networkAddress = address.toZeroHost(16); //1.2.0.0
    
    Parameters:
    
    prefixLength -
    
    Returns:
  - toZeroNetwork
```
IPAddressSegmentSeries toZeroNetwork()
```
    Returns the segment series with a network of zero, the network being the bits within the prefix length. If the series has no prefix length, then it returns an all-zero series.
    The default behaviour is that the resultant series will have the same prefix length. The resultant series will not have a prefix length if AddressNetwork.getPrefixConfiguration() is AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS.
    
    Returns:
    
    See Also:
    
    toZeroHost()
  - includesZeroHost
```
boolean includesZeroHost()
```
    Returns whether the series has a host of zero. If the series has no prefix length, or the prefix length matches the bit count, then returns false. Otherwise, it checks whether all bits past the prefix are zero.
    
    Returns:
  - includesZeroHost
```
boolean includesZeroHost(int prefixLength)
```
    Returns whether all bits past the given prefix length are zero.
    
    Returns:
  - toMaxHost
```
IPAddressSegmentSeries toMaxHost(int prefixLength)
```
    Produces the series with host values of all one bits for the given prefix length.
    If this series has the same prefix length, then the resulting series will too, otherwise the resulting series will have no prefix length.
    This is nearly equivalent to doing the bitwise or (bitwise disjunction) of this address series with the network mask for the given prefix length, but without the possibility of IncompatibleAddressException that can occur when applying a mask to a range of values. Instead, in this case, if the resulting series has a range of values, then the resulting series range boundaries will have host values of all ones, but not necessarily the intervening values.
    For instance, you can get the broadcast address for a subnet of prefix length 16 as follows: String addrStr = "1.2.3.4"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress broadcastAddress = address.toMaxHost(16); //1.2.255.255
    
    Parameters:
    
    prefixLength -
    
    Returns:
  - toMaxHost
```
IPAddressSegmentSeries toMaxHost()
```
    Returns the segment series with a host of all ones. If the series has no prefix length, then it returns an all-ones series.
    The resultant series will have the same prefix length if AddressNetwork.getPrefixConfiguration() is not AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS, otherwise it will no longer have a prefix length.
    For instance, you can get the broadcast address for a subnet as follows: String addrStr = "1.2.3.4/16"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress broadcastAddress = address.toMaxHost(); //1.2.255.255
    
    Returns:
  - includesMaxHost
```
boolean includesMaxHost()
```
    Returns whether the series has a host of all ones. If the series has no prefix length, or the prefix length matches the bit count, then returns false. Otherwise, it checks whether all bits past the prefix are ones.
    
    Returns:
  - includesMaxHost
```
boolean includesMaxHost(int prefixLength)
```
    Returns whether all bits past the given prefix length are all ones.
    
    Returns:
  - reverseSegments
```
IPAddressSegmentSeries reverseSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the segments reversed. This does not throw IncompatibleAddressException since all address series can reverse their segments.
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    Returns:
  - reverseBits
```
IPAddressSegmentSeries reverseBits(boolean perByte)
```
    Returns a new series which has the bits reversed.
    If this has an associated prefix length, then the prefix length is dropped in the reversed series.
    If this represents a range of values that cannot be reversed, because reversing the range results in a set of addresses that cannot be described by a range, then this throws IncompatibleAddressException. In such cases you can call iterator(), getLower(), getUpper() or some other method to transform the address into an address representing a single value before reversing.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the address are reversed
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a subnet that cannot be reversed
  - reverseBytes
```
IPAddressSegmentSeries reverseBytes()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Specified by:
    
    reverseBytes in interface AddressSegmentSeries
    
    Returns:
  - reverseBytesPerSegment
```
IPAddressSegmentSeries reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - removePrefixLength
```
@Deprecated
IPAddressSegmentSeries removePrefixLength()
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length while zeroing out the bits beyond the prefix.
    If the series already has a prefix length, the bits outside the prefix become zero. Use AddressSegmentSeries.withoutPrefixLength() to remove the prefix length without changing the series values.
    Equivalent to calling removePrefixLength(true)
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
    
    See Also:
    
    for an alternative which does not change the address series values.
  - withoutPrefixLength
```
IPAddressSegmentSeries withoutPrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Provides the same address with no prefix. The values remain unchanged.
    Use AddressSegmentSeries.removePrefixLength() as an alternative that deletes the host at the same time by zeroing the host values.
    
    Specified by:
    
    withoutPrefixLength in interface AddressSegmentSeries
  - removePrefixLength
```
@Deprecated
IPAddressSegmentSeries removePrefixLength(boolean zeroed)
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length. If zeroed is false, the bits that were host bits do not become zero, unlike AddressSegmentSeries.removePrefixLength()
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - adjustPrefixBySegment
```
IPAddressSegmentSeries adjustPrefixBySegment(boolean nextSegment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary.
    Follows the same rules as AddressSegmentSeries.adjustPrefixLength(int):
    When prefix length is increased, the bits moved within the prefix become zero. When a prefix length is decreased, the bits moved outside the prefix become zero. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixBySegment(boolean, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    Returns:
  - adjustPrefixBySegment
```
IPAddressSegmentSeries adjustPrefixBySegment(boolean nextSegment,
                                             boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - adjustPrefixLength
```
IPAddressSegmentSeries adjustPrefixLength(int adjustment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment.
    When prefix length is increased, the bits moved within the prefix become zero. When the prefix is extended beyond the segment series boundary, it is removed. When a prefix length is decreased, the bits moved outside the prefix become zero. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixLength(int, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
IPAddressSegmentSeries adjustPrefixLength(int adjustment,
                                          boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Parameters:
    
    adjustment - the increment
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - setPrefixLength
```
IPAddressSegmentSeries setPrefixLength(int prefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    If this series has a prefix length, and the prefix length is increased, the bits moved within the prefix become zero. For an alternative that does not set bits to zero, use AddressSegmentSeries.setPrefixLength(int, boolean) with the second argument as false.
    When the prefix is extended beyond the segment series boundary, it is removed.
    The bits that move from one side of the prefix length to the other (ie bits moved into the prefix or outside the prefix) are zeroed.
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - setPrefixLength
```
IPAddressSegmentSeries setPrefixLength(int prefixLength,
                                       boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    zeroed - whether the bits that move from one side of the prefix length to the other (ie bits moved into the prefix or outside the prefix) are zeroed.
    
    Returns:
  - applyPrefixLength
```
@Deprecated
IPAddressSegmentSeries applyPrefixLength(int networkPrefixLength)
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Applies the given prefix length to create a new segment series.
    Similar to AddressSegmentSeries.setPrefixLength(int) except that prefix lengths are never increased. When this series already has a prefix length that is less than or equal to the requested prefix length, this series is returned.
    Otherwise the returned series has the given prefix length.
    The bits moved outside the prefix will become zero in the returned series.
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)

Interface IPAddressSegmentSeries

Method Summary

Methods inherited from interface inet.ipaddr.format.IPAddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.string.IPAddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.string.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

Method Detail

getPrefixLenComparator

getIPVersion

assignMinPrefixForBlock

assignPrefixForSingleBlock

coverWithPrefixBlock

spanWithPrefixBlocks

spanWithSequentialBlocks

toPrefixBlock

toPrefixBlock

getHostMask

getNetworkMask

getHostSection

getHostSection

getNetworkSection

getNetworkSection

getNetworkSection

toFullString

toPrefixLengthString

toSubnetString

toNormalizedWildcardString

toCanonicalWildcardString

toCompressedWildcardString

toSQLWildcardString

toReverseDNSLookupString

toBinaryString

toSegmentedBinaryString

toOctalString

toStringCollection

toNormalizedString

getNetwork

getSection

getSection

getSection

getSegment

getSegments

getNonZeroHostCount

getLowerNonZeroHost

getLower

getUpper

getIterable

iterator

spliterator

stream

prefixIterator

prefixSpliterator

prefixStream

prefixBlockIterator

prefixBlockSpliterator

prefixBlockStream

nonZeroHostIterator

blockIterator

blockSpliterator

blockStream

sequentialBlockIterator

sequentialBlockSpliterator

sequentialBlockStream

getSequentialBlockCount

segmentsIterator

segmentsSpliterator

segmentsStream

segmentsNonZeroHostIterator

increment

incrementBoundary

toZeroHost

toZeroHost

toZeroNetwork

includesZeroHost

includesZeroHost

toMaxHost