IPAddressSeqRange (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.IPAddressSeqRange

All Implemented Interfaces:

AddressComponentRange, AddressItem, AddressItemRange, IPAddressRange, IPAddressAggregation<IPAddress,IPAddressSeqRange>, Serializable, Comparable<AddressItem>

Direct Known Subclasses:

IPv4AddressSeqRange, IPv6AddressSeqRange
```
public abstract class IPAddressSeqRange
extends Object
implements IPAddressRange
```
This class can be used to represent an arbitrary range of consecutive IP addresses.
Note that the IPAddress and IPAddressString classes allow you to specify a range of values for each segment. That allows you to represent single addresses, any address prefix subnet (eg 1.2.0.0/16 or 1:2:3:4::/64) or any subnet that can be represented with segment ranges (1.2.0-255.* or 1:2:3:4:*), see IPAddressString for details.
IPAddressString and IPAddress cover all potential subnets and addresses that can be represented by a single address string of 4 or less segments for IPv4, and 8 or less segments for IPv6.
This class allows the representation of any sequential address range, including those that cannot be represented by IPAddress.
String representations include the full address for both the lower and upper bounds of the range.

See Also:

Serialized Form

Core

Field Summary

Fields
Modifier and Type Field and Description

static String DEFAULT_RANGE_SEPARATOR

Fields
Modifier and Type	Field and Description
`static String`	`DEFAULT_RANGE_SEPARATOR`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`compareCounts(IPAddressSeqRange other)` Compares the counts of this range with the give range.
`IPAddressSeqRange[]`	`complement()` Returns the complement of the address range within the address space.
`IPAddressSeqRangeList`	`complementIntoList()`
`boolean`	`contains(IPAddress other)` Returns whether this aggregation of addresses contains all addresses in the given address or subnet
`boolean`	`contains(IPAddressSeqRange other)` Returns whether this aggregation of addresses contains all addresses in the given sequential range
`boolean`	`containsPrefixBlock(int prefixLen)` Returns whether the values of this series contains the prefix block for the given prefix length, which means it contains all addresses with the same prefix.
`boolean`	`containsSinglePrefixBlock(int prefixLen)` Returns whether the values of this series contains a single prefix block for the given prefix length.
`abstract IPAddress`	`coverWithPrefixBlock()` Returns the minimal-size prefix block that covers all the addresses in this range.
`BigInteger`	`enumerate(IPAddress other)` Returns the distance of the given address from the initial value of this range.
`boolean`	`equals(Object o)` Returns whether the given sequential address range is equal to this sequential address range.
`IPAddressSeqRange`	`extend(IPAddress other)` Extend this sequential range to include all addresses in the given individual address or subnet.
`IPAddressSeqRange`	`extend(IPAddressRange other)` Extend this sequential range to include all address in the given range, which can be an IPAddress or IPAddressSeqRange.
`IPAddressSeqRange`	`extend(IPAddressSeqRange other)` Extend this sequential range to include all addresses in the given sequential range.
`abstract IPAddress`	`get(BigInteger index)` Returns the individual address at the given index into this sequential range.
`abstract IPAddress`	`get(long index)` Returns the individual address at the given index into this sequential range.
`int`	`getBitCount()` Provides the number of bits comprising this address item
`byte[]`	`getBytes()`
`byte[]`	`getBytes(byte[] bytes)` Copies the bytes of the lowest address item represented by this address item into the supplied array, and returns that array.
`byte[]`	`getBytes(byte[] bytes, int index)` Copies the bytes of the lowest address item represented by this address item into the supplied array starting at the given index, and returns that array.
`BigInteger`	`getCount()` Returns the number of individual addresses in this range.
`abstract Iterable<? extends IPAddress>`	`getIterable()` Useful for using an instance in a "for-each loop", as in `for(addr : address.getIterable()) { ...`
`IPAddress`	`getLower()` Returns the lowest address in the sequential range, the one with the lowest numeric value
`IPAddress`	`getUpper()` Returns the highest address in the sequential range, the one with the highest numeric value
`byte[]`	`getUpperBytes()`
`byte[]`	`getUpperBytes(byte[] bytes)` Copies the bytes of the largest address item represented by this address item into the supplied array, and returns that array.
`byte[]`	`getUpperBytes(byte[] bytes, int index)` Copies the bytes of the largest address item represented by this address item into the supplied array at the given index, and returns that array.
`BigInteger`	`getUpperValue()` Returns the highest value represented by this address item, the highest value included in the range of values
`BigInteger`	`getValue()` Returns the lowest value represented by this address item, the lowest value included in the range of values
`int`	`hashCode()`
`boolean`	`includesMax()` Returns whether this sequential range's upper value is the highest address, the address whose bits are all ones.
`boolean`	`includesZero()` Returns whether this sequential range's lower value is the zero address.
`IPAddressSeqRange`	`intersect(IPAddressSeqRange other)` Returns the intersection of this range with the given range, a range which includes those addresses in both this and the given range.
`IPAddressSeqRangeList`	`intoSequentialRangeList()` Creates a sequential range list from the address, which will contain the same set of individual addresses as this range of addresses.
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`boolean`	`isMax()` Returns whether this sequential range spans from the highest address, the address whose bits are all ones, to itself.
`boolean`	`isMore(IPAddressSeqRange other)` Deprecated. use `compareCounts(IPAddressSeqRange)` instead
`boolean`	`isMultiple()` Returns true if there is more than one address in this range.
`boolean`	`isSequential()` Returns whether the address or subnet represents a range of values that are sequential.
`boolean`	`isZero()` Returns whether this sequential range spans from the zero address to itself.
`abstract Iterator<? extends IPAddress>`	`iterator()` Returns an iterator of the individual addresses in ascending order, following the natural order of IPAddress from lowest numeric value to highest.
`static IPAddressSeqRange[]`	`join(IPAddressSeqRange... ranges)` Joins the given ranges into the fewest number of ranges.
`IPAddressSeqRange`	`join(IPAddressSeqRange other)` Joins two ranges if they are contiguous ranges.
`static IPAddressSeqRangeList[]`	`joinIntoList(IPAddressSeqRange... ranges)` Creates ranges lists from the given ranges.
`IPAddressSeqRangeList`	`joinIntoList(IPAddressSeqRange other)` Joins two ranges.
`IPAddressSeqRange`	`lowerFromSplit(IPAddress other)` Same as split, but returns only the lower range.
`boolean`	`overlaps(IPAddress other)` Returns true if this sequential range overlaps the given address or subnet.
`boolean`	`overlaps(IPAddressSeqRange other)` Returns true if this sequential range overlaps the given sequential range.
`abstract Iterator<? extends IPAddress>`	`prefixBlockIterator(int prefLength)` Iterates through the range of prefix blocks in this range instance using the given prefix length.
`abstract AddressComponentRangeSpliterator<? extends IPAddressSeqRange,? extends IPAddress>`	`prefixBlockSpliterator(int prefLength)` Partitions and traverses through the individual prefix blocks for the given prefix length.
`abstract Stream<? extends IPAddress>`	`prefixBlockStream(int prefLength)` Returns a sequential stream of the prefix blocks for the given prefix length.
`Iterator<? extends IPAddressSeqRange>`	`prefixIterator(int prefixLength)` Iterates through the range of prefixes in this range instance using the given prefix length.
`abstract AddressComponentSpliterator<? extends IPAddressSeqRange>`	`prefixSpliterator(int prefLength)` Partitions and traverses through the individual prefixes for the given prefix length.
`abstract Stream<? extends IPAddressSeqRange>`	`prefixStream(int prefLength)` Returns a sequential stream of the individual prefixes for the given prefix length.
`abstract IPAddress[]`	`spanWithPrefixBlocks()` Produces a minimal array of prefix blocks that spans the same set of addresses.
`abstract IPAddress[]`	`spanWithSequentialBlocks()` Produces a minimal array of blocks that are sequential that cover the same set of addresses.
`IPAddressSeqRange[]`	`split(IPAddress other)` Splits this range at the given address into two ranges, one lower and one upper.
`abstract AddressComponentRangeSpliterator<? extends IPAddressSeqRange,? extends IPAddress>`	`spliterator()` Partitions and traverses through the individual addresses.
`abstract Stream<? extends IPAddress>`	`stream()` Returns a sequential stream of the individual addresses.
`IPAddressSeqRange[]`	`subtract(IPAddressSeqRange other)` Subtracts the given range from this range, to produce either zero, one, or two address ranges that contain the addresses in this range and not in the given range.
`IPAddressSeqRangeList`	`subtractIntoList(IPAddressSeqRange other)` Subtracts the given range from this range, to produce either zero, one, or two address ranges, stored in a IPAddressSeqRangeList, which is sorted, that contain the addresses in this range and not in the given range.
`String`	`toCanonicalString()` Produces a canonical string for the address range.
`String`	`toCanonicalString(String separator)` Produces a canonical string for the address range with the given separator string.
`IPv4AddressSeqRange`	`toIPv4()` If this sequential range is IPv4, or can be converted to IPv4 by applying the same conversion to all address in the range, returns that `IPv4AddressSeqRange`.
`IPv6AddressSeqRange`	`toIPv6()` If this sequential range is IPv6, or can be converted to IPv6 by applying the same conversion to all address in the range, returns that `IPv6AddressSeqRange`.
`String`	`toNormalizedString()` Produces a normalized string for the address range.
`String`	`toNormalizedString(String separator)`
`String`	`toString()` Produces the canonical string for the address, also available from `toCanonicalString()`.
`String`	`toString(Function<? super IPAddress,String> lowerStringer, String separator, Function<? super IPAddress,String> upperStringer)`
`IPAddressSeqRange`	`upperFromSplit(IPAddress other)` Same as split, but returns only the upper range.

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

Methods inherited from interface inet.ipaddr.format.IPAddressRange
intoContainmentTrie, toSequentialRange

Methods inherited from interface inet.ipaddr.IPAddressAggregation
coverWithSequentialRange

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

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, getBitsForCount, getBlockSize, getByteCount, getMinPrefixLengthForBlock, getPrefixCount, getPrefixLengthForSingleBlock, isFullRange

- Field Detail
  - DEFAULT_RANGE_SEPARATOR
```
public static final String DEFAULT_RANGE_SEPARATOR
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getCount
```
public BigInteger getCount()
```
    Description copied from interface: IPAddressRange
    
    Returns the number of individual addresses in this range.
    
    Specified by:
    
    getCount in interface AddressItem
    
    Specified by:
    
    getCount in interface IPAddressRange
    
    Specified by:
    
    getCount in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - isMultiple
```
public boolean isMultiple()
```
    Description copied from interface: IPAddressRange
    
    Returns true if there is more than one address in this range.
    
    Specified by:
    
    isMultiple in interface AddressItem
    
    Specified by:
    
    isMultiple in interface IPAddressRange
    
    Specified by:
    
    isMultiple in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - toIPv4
```
public IPv4AddressSeqRange toIPv4()
```
    If this sequential range is IPv4, or can be converted to IPv4 by applying the same conversion to all address in the range, returns that IPv4AddressSeqRange. Otherwise, returns null.
    
    Returns:
    
    the range
  - toIPv6
```
public IPv6AddressSeqRange toIPv6()
```
    If this sequential range is IPv6, or can be converted to IPv6 by applying the same conversion to all address in the range, returns that IPv6AddressSeqRange. Otherwise, returns null.
    
    Returns:
    
    the range
  - isMore
```
@Deprecated
public boolean isMore(IPAddressSeqRange other)
```
    Deprecated. use compareCounts(IPAddressSeqRange) instead
    
    Parameters:
    
    other - the range to compare, which does not need to range across the same address space
    
    Returns:
    
    whether this range spans more addresses than the provided range.
  - compareCounts
```
public int compareCounts(IPAddressSeqRange other)
```
    Compares the counts of this range with the give range. Rather than calculating counts with getCount(), there can be more efficient ways of comparing whether one range has more addresses than another than another.
    
    Parameters:
    
    other - the range to compare, which does not need to range across the same address space
    
    Returns:
    
    a positive integer if this range has a larger count than the provided, 0 if they are the same, a negative integer if the other has a larger count.
  - getIterable
```
public abstract Iterable<? extends IPAddress> getIterable()
```
    Description copied from interface: IPAddressRange
    
    Useful for using an instance in a "for-each loop", as in for(addr : address.getIterable()) { ... }
    Otherwise just call IPAddressAggregation.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponentRange
    
    Specified by:
    
    getIterable in interface IPAddressRange
    
    Returns:
  - prefixBlockIterator
```
public abstract Iterator<? extends IPAddress> prefixBlockIterator(int prefLength)
```
    Iterates through the range of prefix blocks in this range instance using the given prefix length.
    
    Specified by:
    
    prefixBlockIterator in interface IPAddressRange
    
    Parameters:
    
    prefLength -
    
    Returns:
  - prefixBlockSpliterator
```
public abstract AddressComponentRangeSpliterator<? extends IPAddressSeqRange,? extends IPAddress> prefixBlockSpliterator(int prefLength)
```
    Description copied from interface: IPAddressRange
    
    Partitions and traverses through the individual prefix blocks for the given prefix length.
    
    Specified by:
    
    prefixBlockSpliterator in interface IPAddressRange
    
    Returns:
  - prefixBlockStream
```
public abstract Stream<? extends IPAddress> prefixBlockStream(int prefLength)
```
    Description copied from interface: IPAddressRange
    
    Returns a sequential stream of the prefix blocks for the given prefix length. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixBlockStream in interface IPAddressRange
    
    Returns:
  - prefixIterator
```
public Iterator<? extends IPAddressSeqRange> prefixIterator(int prefixLength)
```
    Iterates through the range of prefixes in this range instance using the given prefix length.
    Since a range between two arbitrary addresses cannot always be represented with a single IPAddress instance, the returned iterator iterates through IPAddressSeqRange instances.
    For instance, if iterating from 1.2.3.4 to 1.2.4.5 with prefix 8, the range shares the same prefix 1, but the range cannot be represented by the address 1.2.3-4.4-5 which does not include 1.2.3.255 or 1.2.4.0 both of which are in the original range. Nor can the range be represented by 1.2.3-4.0-255 which includes 1.2.4.6 and 1.2.3.3, both of which were not in the original range. An IPAddressSeqRange is thus required to represent that prefixed range.
    
    Specified by:
    
    prefixIterator in interface IPAddressRange
    
    Parameters:
    
    prefixLength -
    
    Returns:
  - prefixSpliterator
```
public abstract AddressComponentSpliterator<? extends IPAddressSeqRange> prefixSpliterator(int prefLength)
```
    Description copied from interface: IPAddressRange
    
    Partitions and traverses through the individual prefixes for the given prefix length.
    
    Specified by:
    
    prefixSpliterator in interface IPAddressRange
    
    Returns:
  - prefixStream
```
public abstract Stream<? extends IPAddressSeqRange> prefixStream(int prefLength)
```
    Description copied from interface: IPAddressRange
    
    Returns a sequential stream of the individual prefixes for the given prefix length. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixStream in interface IPAddressRange
    
    Returns:
  - iterator
```
public abstract Iterator<? extends IPAddress> iterator()
```
    Description copied from interface: IPAddressAggregation
    
    Returns an iterator of the individual addresses in ascending order, following the natural order of IPAddress from lowest numeric value to highest.
    
    Specified by:
    
    iterator in interface AddressComponentRange
    
    Specified by:
    
    iterator in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - spliterator
```
public abstract AddressComponentRangeSpliterator<? extends IPAddressSeqRange,? extends IPAddress> spliterator()
```
    Description copied from interface: IPAddressRange
    
    Partitions and traverses through the individual addresses.
    
    Specified by:
    
    spliterator in interface AddressComponentRange
    
    Specified by:
    
    spliterator in interface IPAddressRange
    
    Specified by:
    
    spliterator in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - stream
```
public abstract Stream<? extends IPAddress> stream()
```
    Description copied from interface: IPAddressAggregation
    
    Returns a sequential stream of the individual addresses. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    stream in interface AddressComponentRange
    
    Specified by:
    
    stream in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - getLower
```
public IPAddress getLower()
```
    Returns the lowest address in the sequential range, the one with the lowest numeric value
    
    Specified by:
    
    getLower in interface AddressComponentRange
    
    Specified by:
    
    getLower in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - getUpper
```
public IPAddress getUpper()
```
    Returns the highest address in the sequential range, the one with the highest numeric value
    
    Specified by:
    
    getUpper in interface AddressComponentRange
    
    Specified by:
    
    getUpper in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - get
```
public abstract IPAddress get(BigInteger index)
```
    Returns the individual address at the given index into this sequential range.
    If the increment is negative, or the increment exceeds getCount() - 1, this method throws IndexOutOfBoundsException.
    Otherwise, this returns the address that is the given index upwards into the list of sequential ranges, with the increment of zero returning the first address.
    
    Parameters:
    
    index -
    
    Returns:
  - get
```
public abstract IPAddress get(long index)
```
    Returns the individual address at the given index into this sequential range.
    If the increment is negative, or the increment exceeds getCount() - 1, this method throws IndexOutOfBoundsException.
    Otherwise, this returns the address that is the given index upwards into the list of sequential ranges, with the increment of zero returning the first address.
    
    Parameters:
    
    index -
    
    Returns:
  - toNormalizedString
```
public String toNormalizedString(String separator)
```
  - toNormalizedString
```
public String toNormalizedString()
```
    Produces a normalized string for the address range. It has the format "lower -> upper" where lower and upper are the normalized strings for the lowest and highest addresses in the range, given by getLower() and getUpper().
    
    Specified by:
    
    toNormalizedString in interface IPAddressRange
    
    Returns:
  - toCanonicalString
```
public String toCanonicalString(String separator)
```
    Produces a canonical string for the address range with the given separator string.
  - toCanonicalString
```
public String toCanonicalString()
```
    Produces a canonical string for the address range. It has the format "lower -> upper" where lower and upper are the canonical strings for the lowest and highest addresses in the range, given by getLower() and getUpper().
    
    Specified by:
    
    toCanonicalString in interface IPAddressRange
    
    Returns:
  - toString
```
public String toString(Function<? super IPAddress,String> lowerStringer,
                       String separator,
                       Function<? super IPAddress,String> upperStringer)
```
  - toString
```
public String toString()
```
    Produces the canonical string for the address, also available from toCanonicalString().
    
    Overrides:
    
    toString in class Object
  - coverWithPrefixBlock
```
public abstract IPAddress coverWithPrefixBlock()
```
    Returns the minimal-size prefix block that covers all the addresses in this range. The resulting block will have a larger count than this, unless this range already directly corresponds to a prefix block.
    
    Specified by:
    
    coverWithPrefixBlock in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
  - spanWithPrefixBlocks
```
public abstract IPAddress[] spanWithPrefixBlocks()
```
    Description copied from interface: IPAddressRange
    
    Produces a minimal array of prefix blocks that spans the same set of addresses.
    
    Specified by:
    
    spanWithPrefixBlocks in interface IPAddressRange
  - spanWithSequentialBlocks
```
public abstract IPAddress[] spanWithSequentialBlocks()
```
    Description copied from interface: IPAddressRange
    
    Produces a minimal array of blocks that are sequential that cover the same set of addresses. This array can be shorter than that produced by IPAddressRange.spanWithPrefixBlocks() and is never longer.
    
    Specified by:
    
    spanWithSequentialBlocks in interface IPAddressRange
  - join
```
public static IPAddressSeqRange[] join(IPAddressSeqRange... ranges)
```
    Joins the given ranges into the fewest number of ranges. This method can handle null ranges, which are ignored. The returned array will never be null and will be sorted by ascending lowest range value.
    If the input ranges are both IPv4 and IPv6, then the joined IPv4 ranges will be followed by the joined IPv6 ranges.
    
    Parameters:
    
    ranges -
    
    Returns:
  - joinIntoList
```
public static IPAddressSeqRangeList[] joinIntoList(IPAddressSeqRange... ranges)
```
    Creates ranges lists from the given ranges. If the input ranges comprise multiple versions of IP addresses, then multiple lists will be returned, the IPv4 followed by the IPv6 list. If there are no non-null input ranges, then a zero-length array is returned.
    
    Parameters:
    
    ranges -
    
    Returns:
  - overlaps
```
public boolean overlaps(IPAddress other)
```
    Returns true if this sequential range overlaps the given address or subnet.
    
    Specified by:
    
    overlaps in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Parameters:
    
    other -
    
    Returns:
  - overlaps
```
public boolean overlaps(IPAddressSeqRange other)
```
    Returns true if this sequential range overlaps the given sequential range.
    
    Specified by:
    
    overlaps in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Parameters:
    
    other -
    
    Returns:
  - contains
```
public boolean contains(IPAddress other)
```
    Description copied from interface: IPAddressAggregation
    
    Returns whether this aggregation of addresses contains all addresses in the given address or subnet
    
    Specified by:
    
    contains in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - contains
```
public boolean contains(IPAddressSeqRange other)
```
    Description copied from interface: IPAddressAggregation
    
    Returns whether this aggregation of addresses contains all addresses in the given sequential range
    
    Specified by:
    
    contains in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
  - enumerate
```
public BigInteger enumerate(IPAddress other)
```
    Returns the distance of the given address from the initial value of this range. Indicates where an address sits relative to the range ordering.
    If within or above the range, it is the distance to the lower boundary of the sequential range. If below the range, returns the number of addresses following the address to the lower range boundary.
    The method does not return null if this range does not contain the address. You can call contains(IPAddress) or you can compare with getCount() to check for containment. An address is in the range if 0 <= enumerate(IPAddress) < getCount().
    Returns null when the argument is a multi-valued subnet. The argument must be an individual address.
    If the given address does not have the same version or type as the addresses in this range, then null is returned.
    
    Specified by:
    
    enumerate in interface IPAddressRange
    
    Returns:
  - isSequential
```
public boolean isSequential()
```
    Returns whether the address or subnet represents a range of values that are sequential.
    IP address sequential ranges are sequential by definition, so this returns true.
    
    Specified by:
    
    isSequential in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
    
    true
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object o)
```
    Returns whether the given sequential address range is equal to this sequential address range. Two sequential address ranges are equal if their lower and upper range boundaries are equal.
    
    Overrides:
    
    equals in class Object
  - intersect
```
public IPAddressSeqRange intersect(IPAddressSeqRange other)
```
    Returns the intersection of this range with the given range, a range which includes those addresses in both this and the given range.
    
    Parameters:
    
    other -
    
    Returns:
  - join
```
public IPAddressSeqRange join(IPAddressSeqRange other)
```
    Joins two ranges if they are contiguous ranges. If this range overlaps the given range, or if the highest value of the lower range is one below the lowest value of the higher range, then the two are joined into a new larger range that is returned.
    Otherwise, null is returned.
    Use joinIntoList(IPAddressSeqRange) if you wish the result to match the original inputs. That method returns a list which contains both this and the given range, regardless of whether they can be joined into a single range.
    
    Parameters:
    
    other -
    
    Returns:
  - joinIntoList
```
public IPAddressSeqRangeList joinIntoList(IPAddressSeqRange other)
```
    Joins two ranges. Similar to join(IPAddressSeqRange), but instead the result includes all the addresses in both ranges, regardless of whether they are contiguous.
    
    Parameters:
    
    other -
    
    Returns:
  - extend
```
public IPAddressSeqRange extend(IPAddress other)
```
    Extend this sequential range to include all addresses in the given individual address or subnet. If the argument has a different IP version than this, null is returned. Otherwise, this method returns the range that includes this range, the given address or subnet, and all addresses in-between.
    
    Parameters:
    
    other -
    
    Returns:
  - extend
```
public IPAddressSeqRange extend(IPAddressSeqRange other)
```
    Extend this sequential range to include all addresses in the given sequential range. If the argument has a different IP version than this, null is returned. Otherwise, this method returns the range that includes this range, the given sequential range, and all addresses in-between.
    
    Parameters:
    
    other -
    
    Returns:
  - extend
```
public IPAddressSeqRange extend(IPAddressRange other)
```
    Extend this sequential range to include all address in the given range, which can be an IPAddress or IPAddressSeqRange. If the argument has a different IP version than this, null is returned. Otherwise, this method returns the range that includes this range, the given range, and all addresses in-between.
    
    Parameters:
    
    other -
    
    Returns:
  - subtract
```
public IPAddressSeqRange[] subtract(IPAddressSeqRange other)
```
    Subtracts the given range from this range, to produce either zero, one, or two address ranges that contain the addresses in this range and not in the given range. If the result has length 2, the two ranges are ordered by ascending lowest range value.
    
    Parameters:
    
    other -
    
    Returns:
  - subtractIntoList
```
public IPAddressSeqRangeList subtractIntoList(IPAddressSeqRange other)
```
    Subtracts the given range from this range, to produce either zero, one, or two address ranges, stored in a IPAddressSeqRangeList, which is sorted, that contain the addresses in this range and not in the given range.
    
    Parameters:
    
    other -
    
    Returns:
  - complement
```
public IPAddressSeqRange[] complement()
```
    Description copied from interface: IPAddressRange
    
    Returns the complement of the address range within the address space.
    Returns a minimal array of IP address sequential ranges instances containing the addresses not contained within this address range.
    
    Specified by:
    
    complement in interface IPAddressRange
    
    Returns:
  - complementIntoList
```
public IPAddressSeqRangeList complementIntoList()
```
  - split
```
public IPAddressSeqRange[] split(IPAddress other)
```
    Splits this range at the given address into two ranges, one lower and one upper. The second range starts with the lower address of the given address or subnet. The first range consists of all preceding addresses.
    This is similar to subtract, but without removing the given address or subnet from the result.
    Unlike subtract, this always returns an array of length two. In some cases, one or both of the two returned ranges is null.
    If the given address or subnet includes the first address in this range, or all addresses of the given address or subnet are below the lower value of this range, then the first range is null, and the second range is the same range as this range.
    If all addresses of the given address or subnet are above the upper value of this range, then the first range is is the same range as this range, and the second range is null.
    If the given address has a different version than this, then both returned ranges is null.
    
    Parameters:
    
    other -
    
    Returns:
  - lowerFromSplit
```
public IPAddressSeqRange lowerFromSplit(IPAddress other)
```
    Same as split, but returns only the lower range.
    
    Parameters:
    
    other -
    
    Returns:
  - upperFromSplit
```
public IPAddressSeqRange upperFromSplit(IPAddress other)
```
    Same as split, but returns only the upper range.
    
    Parameters:
    
    other -
    
    Returns:
  - intoSequentialRangeList
```
public IPAddressSeqRangeList intoSequentialRangeList()
```
    Description copied from interface: IPAddressRange
    
    Creates a sequential range list from the address, which will contain the same set of individual addresses as this range of addresses.
    Unlike IPAddressAggregation.coverWithSequentialRange(), the returned list will always contain the same set of addresses as this range, regardless of whether this range of addresses is sequential or not.
    
    Specified by:
    
    intoSequentialRangeList in interface IPAddressRange
    
    Returns:
  - containsPrefixBlock
```
public boolean containsPrefixBlock(int prefixLen)
```
    Description copied from interface: AddressItem
    
    Returns whether the values of this series contains the prefix block for the given prefix length, which means it contains all addresses with the same prefix.
    Use AddressItem.getMinPrefixLengthForBlock() to determine the smallest prefix length for which this method returns true.
    
    Specified by:
    
    containsPrefixBlock in interface AddressItem
    
    Returns:
  - containsSinglePrefixBlock
```
public boolean containsSinglePrefixBlock(int prefixLen)
```
    Description copied from interface: AddressItem
    
    Returns whether the values of this series contains a single prefix block for the given prefix length.
    Use AddressItem.getPrefixLengthForSingleBlock() to determine whether there is a prefix length for which this method returns true.
    
    Specified by:
    
    containsSinglePrefixBlock in interface AddressItem
    
    Returns:
  - getBitCount
```
public int getBitCount()
```
    Description copied from interface: AddressItem
    
    Provides the number of bits comprising this address item
    
    Specified by:
    
    getBitCount in interface AddressItem
    
    Returns:
    
    the number of bits
  - getBytes
```
public byte[] getBytes()
```
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address item represented by this address item
  - getBytes
```
public byte[] getBytes(byte[] bytes)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the lowest address item represented by this address item into the supplied array, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned.
    
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address represented by this address item.
  - getBytes
```
public byte[] getBytes(byte[] bytes,
                       int index)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the lowest address item represented by this address item into the supplied array starting at the given index, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned, with the rest of the array contents the same as the original.
    
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address represented by this address item.
  - getUpperBytes
```
public byte[] getUpperBytes()
```
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
    
    the bytes of the largest address item represented by this address item
  - getUpperBytes
```
public byte[] getUpperBytes(byte[] bytes)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the largest address item represented by this address item into the supplied array, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned, with the rest of the array contents the same as the original.
    
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
    
    the bytes of the largest address represented by this address item.
  - getUpperBytes
```
public byte[] getUpperBytes(byte[] bytes,
                            int index)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the largest address item represented by this address item into the supplied array at the given index, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned.
    
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
    
    the bytes of the largest address represented by this address item.
  - getValue
```
public BigInteger getValue()
```
    Description copied from interface: AddressItem
    
    Returns the lowest value represented by this address item, the lowest value included in the range of values
    
    Specified by:
    
    getValue in interface AddressItem
    
    Returns:
    
    the lowest value represented by this address item
  - getUpperValue
```
public BigInteger getUpperValue()
```
    Description copied from interface: AddressItem
    
    Returns the highest value represented by this address item, the highest value included in the range of values
    
    Specified by:
    
    getUpperValue in interface AddressItem
    
    Returns:
    
    the highest value represented by this address item
  - isZero
```
public boolean isZero()
```
    Returns whether this sequential range spans from the zero address to itself.
    
    Specified by:
    
    isZero in interface AddressItem
    
    Returns:
    
    whether this item matches the value of zero
  - includesZero
```
public boolean includesZero()
```
    Returns whether this sequential range's lower value is the zero address.
    
    Specified by:
    
    includesZero in interface AddressItem
    
    Specified by:
    
    includesZero in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
    
    whether this item includes the value of zero within its range
  - isMax
```
public boolean isMax()
```
    Returns whether this sequential range spans from the highest address, the address whose bits are all ones, to itself.
    
    Specified by:
    
    isMax in interface AddressItem
    
    Returns:
    
    whether this item matches the maximum possible value
  - includesMax
```
public boolean includesMax()
```
    Returns whether this sequential range's upper value is the highest address, the address whose bits are all ones.
    
    Specified by:
    
    includesMax in interface AddressItem
    
    Specified by:
    
    includesMax in interface IPAddressAggregation<IPAddress,IPAddressSeqRange>
    
    Returns:
    
    whether this item includes the maximum possible value within its range

Class IPAddressSeqRange

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.format.IPAddressRange

Methods inherited from interface inet.ipaddr.IPAddressAggregation

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

Field Detail

DEFAULT_RANGE_SEPARATOR

Method Detail

getCount

isMultiple

isIPv4

isIPv6

toIPv4

toIPv6

isMore

compareCounts

getIterable

prefixBlockIterator

prefixBlockSpliterator

prefixBlockStream

prefixIterator

prefixSpliterator

prefixStream

iterator

spliterator

stream

getLower

getUpper

get

get

toNormalizedString

toNormalizedString

toCanonicalString

toCanonicalString

toString

toString

coverWithPrefixBlock

spanWithPrefixBlocks

spanWithSequentialBlocks

join

joinIntoList

overlaps

overlaps

contains

contains

enumerate

isSequential

hashCode

equals

intersect

join

joinIntoList

extend

extend

extend

subtract

subtractIntoList

complement

complementIntoList

split

lowerFromSplit

upperFromSplit

intoSequentialRangeList

containsPrefixBlock

containsSinglePrefixBlock

getBitCount

getBytes

getBytes

getBytes

getUpperBytes

getUpperBytes

getUpperBytes

getValue

getUpperValue

isZero

includesZero

isMax