IPAddress (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.Address
- - inet.ipaddr.IPAddress

All Implemented Interfaces:

AddressComponent, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressItemRange, IPAddressDivisionSeries, IPAddressRange, inet.ipaddr.format.string.AddressStringDivisionSeries, inet.ipaddr.format.string.IPAddressStringDivisionSeries, IPAddressSegmentSeries, java.io.Serializable, java.lang.Comparable<AddressItem>

Direct Known Subclasses:

IPv4Address, IPv6Address
```
public abstract class IPAddress
extends Address
implements IPAddressSegmentSeries, IPAddressRange
```
A single IP address, or a subnet of multiple addresses. Subnets have one or more segments that are a range of values.
IPAddress objects are immutable and cannot change values. This also makes them thread-safe.
String creation:
There are several public classes used to customize IP address strings. For single strings from an address or address section, you use IPAddressSection.IPStringOptions or IPv6AddressSection.IPv6StringOptions along with toNormalizedString(IPAddressSection.IPStringOptions). Or you use one of the methods like Address.toCanonicalString() which does the same.
For string collections from an address or address section, use IPv4AddressSection.IPv4StringBuilderOptions, IPv6AddressSection.IPv6StringBuilderOptions, IPAddressSection.IPStringBuilderOptions along with toStringCollection(IPAddressSection.IPStringBuilderOptions) or toStrings(IPAddressSection.IPStringBuilderOptions). Or you use one of the methods toStandardStringCollection(), toAllStringCollection(), toStandardStrings(), toAllStrings() which does the same.

See Also:

Serialized Form

Core

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface IPAddress.IPAddressValueProvider

static class IPAddress.IPVersion
- Nested classes/interfaces inherited from class inet.ipaddr.Address
  Address.AddressValueProvider, Address.SegmentValueProvider

Nested Classes
Modifier and Type	Class and Description
`static interface`	`IPAddress.IPAddressValueProvider`
`static class`	`IPAddress.IPVersion`

Field Summary

Fields
Modifier and Type	Field and Description
`static IPAddressConverter`	`DEFAULT_ADDRESS_CONVERTER` The default way by which addresses are converted, initialized to an instance of `IPAddressConverter.DefaultAddressConverter`
`static char`	`PREFIX_LEN_SEPARATOR`

Fields inherited from class inet.ipaddr.Address
ADDRESS_LOW_VALUE_COMPARATOR, ALTERNATIVE_RANGE_SEPARATOR, ALTERNATIVE_RANGE_SEPARATOR_STR, ALTERNATIVE_SEGMENT_WILDCARD_STR, DEFAULT_ADDRESS_COMPARATOR, HEX_PREFIX, OCTAL_PREFIX, RANGE_SEPARATOR, RANGE_SEPARATOR_STR, SEGMENT_SQL_SINGLE_WILDCARD, SEGMENT_SQL_SINGLE_WILDCARD_STR, SEGMENT_SQL_WILDCARD, SEGMENT_SQL_WILDCARD_STR, SEGMENT_WILDCARD, SEGMENT_WILDCARD_STR

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract IPAddress`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`abstract IPAddress`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`abstract IPAddress`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`abstract IPAddress`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`abstract IPAddress`	`applyPrefixLength(int networkPrefixLength)` Applies the given prefix length to create a new segment series.
`IPAddress`	`assignMinPrefixForBlock()` Constructs an equivalent address with the smallest CIDR prefix possible (largest network), such that the range of values are a set of subnet blocks for that prefix.
`IPAddress`	`assignPrefixForSingleBlock()` Returns the equivalent CIDR address with a prefix length for which the address subnet block matches the range of values in this address.
`abstract IPAddress`	`bitwiseOr(IPAddress mask)` Equivalent to calling `bitwiseOr(IPAddress, boolean)` with the second argument as false.
`abstract IPAddress`	`bitwiseOr(IPAddress mask, boolean retainPrefix)` Does the bitwise disjunction with this address.
`abstract IPAddress`	`bitwiseOrNetwork(IPAddress mask, int networkPrefixLength)` Does the bitwise disjunction with this address.
`abstract java.util.Iterator<? extends IPAddress>`	`blockIterator(int segmentCount)` Iterates through series that can be obtained by iterating through all the upper segments up to the given segment count.
`boolean`	`contains(IPAddress other)` Returns whether this contains all values of the given address
`boolean`	`contains(IPAddressSeqRange other)` Returns whether this range contains all addresses in the given sequential range
`static int`	`getBitCount(IPAddress.IPVersion version)`
`int`	`getBitsPerSegment()` Returns the number of bits comprising each segment in this series.
`java.lang.Integer`	`getBlockMaskPrefixLength(boolean network)` If this address is equivalent to the mask for a CIDR prefix block, it returns that prefix length.
`int`	`getByteCount()`
`static int`	`getByteCount(IPAddress.IPVersion version)`
`int`	`getBytesPerSegment()` Returns the number of bytes comprising each segment in this series.
`IPAddress.IPVersion`	`getIPVersion()` Returns the version of this segment series
`abstract java.lang.Iterable<? extends IPAddress>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract IPAddress`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`abstract IPAddress`	`getLowerNonZeroHost()` Similar to `IPAddressSegmentSeries.getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`void`	`getMatchesSQLClause(java.lang.StringBuilder builder, java.lang.String sqlExpression)` Returns a clause for matching this address.
`void`	`getMatchesSQLClause(java.lang.StringBuilder builder, java.lang.String sqlExpression, IPAddressSQLTranslator translator)` Returns a clause for matching this address.
`int`	`getMaxSegmentValue()`
`abstract IPAddressNetwork<?,?,?,?,?>`	`getNetwork()` Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`java.lang.Integer`	`getNetworkPrefixLength()` Returns the CIDR network prefix length of the series, or null if the series has no associated prefix length.
`java.math.BigInteger`	`getNonZeroHostCount()` Gets the count of single value series that this series may represent, but excluding series whose host is zero.
`inet.ipaddr.format.string.IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions options)` Returns all the ways of breaking this address down into segments, as selected.
`IPAddressSection`	`getSection()` Returns the address as an address section comprising all segments in the address.
`IPAddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`IPAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`static int`	`getSegmentCount(IPAddress.IPVersion version)`
`java.math.BigInteger`	`getSequentialBlockCount()` provides the count of elements from the `IPAddressSegmentSeries.sequentialBlockIterator()`, the minimal number of sequential subseries that comprise this series
`abstract IPAddress`	`getUpper()` 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.
`boolean`	`includesMaxHost()` Returns whether the series has a host of all ones.
`boolean`	`includesMaxHost(int networkPrefixLength)` 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 networkPrefixLength)` Returns whether all bits past the given prefix length are zero.
`abstract IPAddress`	`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.
`abstract IPAddress`	`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.
`abstract IPAddress`	`intersect(IPAddress other)` Produces the subnet whose addresses are found in both this and the given subnet argument, or null if no such addresses.
`boolean`	`isAnyLocal()` Returns whether this address is the address which binds to any address on the local host.
`boolean`	`isIPv4()`
`abstract boolean`	`isIPv4Convertible()` Determines whether this address can be converted to IPv4, if not IPv4 already.
`boolean`	`isIPv6()`
`abstract boolean`	`isIPv6Convertible()` Determines whether an address can be converted to IPv6, if not IPv6 already.
`abstract boolean`	`isLinkLocal()` Returns whether the address is link local, whether unicast or multicast.
`abstract boolean`	`isLocal()` Returns true if the address is link local, site local, organization local, administered locally, or unspecified.
`abstract boolean`	`isLoopback()`
`boolean`	`isSingleNetwork()` Returns true if the network section of the address spans just a single value
`boolean`	`isUnspecified()` The unspecified address is the address that is all zeros.
`abstract java.util.Iterator<? extends IPAddress>`	`iterator()` Iterates through the individual segment series.
`abstract IPAddress`	`mask(IPAddress mask)` Equivalent to calling `mask(IPAddress, boolean)` with the second argument as false.
`abstract IPAddress`	`mask(IPAddress mask, boolean retainPrefix)` Applies the given mask to all addresses represented by this IPAddress.
`abstract IPAddress`	`maskNetwork(IPAddress mask, int networkPrefixLength)` Applies the given mask to all addresses represented by this IPAddress while also applying the given prefix length at the same time.
`boolean`	`matches(IPAddressString otherString)`
`boolean`	`matchesWithMask(IPAddress other, IPAddress mask)` Applies the mask to this address and then compares values with the given address
`abstract IPAddress[]`	`mergeToPrefixBlocks(IPAddress... addresses)` Merges this with the list of addresses to produce the smallest list of prefix blocks
`abstract IPAddress[]`	`mergeToSequentialBlocks(IPAddress... addresses)` Merges this with the list of subnets to produce the smallest list of block subnets that are sequential.
`abstract java.util.Iterator<? extends IPAddress>`	`nonZeroHostIterator()` Similar to the prefix block iterator, but series with a host of zero are skipped.
`abstract java.util.Iterator<? extends IPAddress>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`abstract java.util.Iterator<? extends IPAddress>`	`prefixIterator()` Iterates through the individual prefixes.
`abstract IPAddress`	`removePrefixLength()` Removes the prefix length while zeroing out the existing host.
`abstract IPAddress`	`removePrefixLength(boolean zeroed)` Removes the prefix length.
`abstract IPAddress`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`abstract IPAddress`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`abstract IPAddress`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`abstract IPAddress`	`reverseSegments()` Returns a new segment series with the segments reversed.
`java.util.Iterator<? extends IPAddress>`	`sequentialBlockIterator()` Iterates through the sequential series that make up this series.
`abstract IPAddress`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`abstract IPAddress`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`abstract IPAddress[]`	`spanWithPrefixBlocks(IPAddress other)` Produces the list of prefix block subnets that span from this subnet to the given subnet.
`abstract IPAddressSeqRange`	`spanWithRange(IPAddress other)` Produces an IPAddressRange instance that spans this subnet to the given subnet.
`abstract IPAddress[]`	`spanWithSequentialBlocks(IPAddress other)` Produces a list of sequential block subnets that span all values from this subnet to the given subnet.
`abstract IPAddress[]`	`subtract(IPAddress other)` Subtract the given subnet from this subnet, returning an array of subnets for the result (the subnets will not be contiguous so an array is required).
`IPAddressString`	`toAddressString()` Generates an IPAddressString object for this IPAddress object.
`IPAddressPartStringCollection`	`toAllStringCollection()`
`java.lang.String[]`	`toAllStrings()` Produces almost all possible string variations
`java.lang.String`	`toBinaryString()` Writes this address as a single binary value with always the exact same number of characters
`HostName`	`toCanonicalHostName()` Does a reverse name lookup to get the canonical host name.
`java.lang.String`	`toCanonicalWildcardString()` This produces a string similar to the canonical string but avoids the CIDR prefix.
`java.lang.String`	`toCompressedWildcardString()` This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
`java.lang.String`	`toConvertedString()` Returns a mixed string if it represents a convertible IPv4 address, returns the normalized string otherwise.
`static java.lang.String`	`toDelimitedSQLStrs(java.lang.String[] strs)`
`java.lang.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.
`HostName`	`toHostName()` If this address was resolved from a host, returns that host.
`java.net.InetAddress`	`toInetAddress()` Converts the lowest value of this address to an InetAddress
`IPv4Address`	`toIPv4()` If this address is IPv4, or can be converted to IPv4, returns that `IPv4Address`.
`IPv6Address`	`toIPv6()`
`abstract IPAddress`	`toMaxHost()` Returns the segment series with a host of all ones.
`abstract IPAddress`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`static java.lang.String`	`toNormalizedString(IPAddress.IPAddressValueProvider provider)` Allows for the creation of a normalized string without creating a full IP address object first.
`static void`	`toNormalizedString(IPAddress.IPAddressValueProvider provider, java.lang.StringBuilder builder)` Allows for the creation of a normalized string without creating a full IP address object first.
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions params)` Constructs a string representing this address according to the given parameters
`java.lang.String`	`toNormalizedWildcardString()` This produces a string similar to the normalized string but avoids the CIDR prefix.
`java.lang.String`	`toOctalString(boolean with0Prefix)` Writes this address as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix.
`abstract IPAddress`	`toPrefixBlock()` Returns the subnet associated with the prefix length of this address.
`abstract IPAddress`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`java.lang.String`	`toPrefixLengthString()` Returns a string with a CIDR network prefix length if this address has a network prefix length.
`java.lang.String`	`toReverseDNSLookupString()` Generates the reverse DNS lookup string
`abstract IPAddressSeqRange`	`toSequentialRange()` Creates a sequential range instance from the lowest and highest addresses in this subnet
`abstract IPAddressSeqRange`	`toSequentialRange(IPAddress other)` Creates a sequential range instance from this and the given address, spanning from the lowest to the highest addresses in the two subnets If the other address is a different version than this, then the default conversion is applied to the other address first using `toIPv4()` or `toIPv6()`
`java.lang.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`	`toStandardStringCollection()`
`java.lang.String[]`	`toStandardStrings()` Returns at most a few dozen string representations: -mixed (1:2:3:4:5:6:1.2.3.4) -full compressions (a:0:b:c:d:0:e:f or a::b:c:d:0:e:f or a:0:b:c:d::e:f) -full leading zeros (000a:0000:000b:000c:000d:0000:000e:000f) -all uppercase and all lowercase (a::a can be A::A) -combinations thereof
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions options)`
`java.lang.String[]`	`toStrings(IPAddressSection.IPStringBuilderOptions options)` Rather than using toAllStrings or StandardStrings, you can use this method to customize the list of strings produced for this address
`java.lang.String`	`toSubnetString()` Produces a consistent subnet string that looks like 1.2.. or 1:2::/16 In the case of IPv4, this means that wildcards are used instead of a network prefix when a network prefix has been supplied.
`abstract java.lang.String`	`toUNCHostName()` Generates the Microsoft UNC path component for this address
`java.net.InetAddress`	`toUpperInetAddress()` Converts the highest value of this address to an InetAddress.
`abstract IPAddress`	`toZeroHost()` Returns the segment series with a host of zero.
`abstract IPAddress`	`toZeroHost(int prefixLength)` Produces the series with host values of 0 for the given prefix length.
`abstract IPAddress`	`withoutPrefixLength()` Provides the same address with no prefix.

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

Methods inherited from interface inet.ipaddr.IPAddressSegmentSeries
getHostSection, getHostSection, getNetworkSection, getNetworkSection, getNetworkSection, getSegment, getSegments, segmentsIterator, segmentsNonZeroHostIterator

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

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

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getSegmentCount, getSegments, getSegments, getSegmentStrings, toCanonicalString, toCompressedString

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getBitCount, getBlockCount, getCount, getDivisionStrings, getPrefixCount, getPrefixCount, getPrefixLength, 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.AddressItem
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBytes, getBytes, getBytes, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, includesMax, includesZero, isFullRange, isMax, isMultiple, isZero, testRange, testRange

Methods inherited from interface inet.ipaddr.format.IPAddressRange
prefixBlockIterator, prefixIterator, spanWithPrefixBlocks, spanWithSequentialBlocks, toCanonicalString, toNormalizedString

- Field Detail
  - PREFIX_LEN_SEPARATOR
```
public static final char PREFIX_LEN_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - DEFAULT_ADDRESS_CONVERTER
```
public static final IPAddressConverter DEFAULT_ADDRESS_CONVERTER
```
    The default way by which addresses are converted, initialized to an instance of IPAddressConverter.DefaultAddressConverter
- Method Detail
  - toHostName
```
public HostName toHostName()
```
    If this address was resolved from a host, returns that host. Otherwise, does a reverse name lookup.
  - toCanonicalHostName
```
public HostName toCanonicalHostName()
```
    Does a reverse name lookup to get the canonical host name. Note that the canonical host name may differ on different systems, as it aligns with InetAddress.getCanonicalHostName() In particular, on some systems the loopback address has canonical host localhost and on others the canonical host is the same loopback address.
  - getNetwork
```
public abstract IPAddressNetwork<?,?,?,?,?> getNetwork()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressSegmentSeries
    
    Specified by:
    
    getNetwork in interface inet.ipaddr.format.string.IPAddressStringDivisionSeries
    
    Specified by:
    
    getNetwork in interface IPAddressSegmentSeries
    
    Returns:
  - getSection
```
public IPAddressSection getSection()
```
    Returns the address as an address section comprising all segments in the address.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class Address
    
    Returns:
  - getSection
```
public IPAddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Returns:
  - getSection
```
public 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
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Returns:
  - getParts
```
public inet.ipaddr.format.string.IPAddressStringDivisionSeries[] getParts(IPAddressSection.IPStringBuilderOptions options)
```
    Returns all the ways of breaking this address down into segments, as selected.
    
    Returns:
  - getMaxSegmentValue
```
public int getMaxSegmentValue()
```
    Specified by:
    
    getMaxSegmentValue in interface AddressSegmentSeries
    
    Returns:
    
    the maximum possible segment value for this type of address. Note this is not the maximum value of the range of segment values in this specific address, this is the maximum value of any segment for this address type, and is usually determined by the number of bits per segment.
  - getNonZeroHostCount
```
public java.math.BigInteger getNonZeroHostCount()
```
    Description copied from interface: IPAddressSegmentSeries
    
    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().
    
    Specified by:
    
    getNonZeroHostCount in interface IPAddressSegmentSeries
    
    Returns:
  - getBytesPerSegment
```
public int getBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of bytes comprising each segment in this series. Segments in the same series are equal length.
    
    Specified by:
    
    getBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - getBitsPerSegment
```
public int getBitsPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of bits comprising each segment in this series. Segments in the same series are equal length.
    
    Specified by:
    
    getBitsPerSegment in interface AddressSegmentSeries
    
    Returns:
  - getByteCount
```
public int getByteCount()
```
    Specified by:
    
    getByteCount in interface AddressItem
    
    Overrides:
    
    getByteCount in class Address
    
    Returns:
    
    the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
  - getByteCount
```
public static int getByteCount(IPAddress.IPVersion version)
```
  - getSegmentCount
```
public static int getSegmentCount(IPAddress.IPVersion version)
```
  - getBitCount
```
public static int getBitCount(IPAddress.IPVersion version)
```
  - getLowerNonZeroHost
```
public abstract IPAddress getLowerNonZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Similar to IPAddressSegmentSeries.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 IPAddressSegmentSeries.getLower().
    
    Specified by:
    
    getLowerNonZeroHost in interface IPAddressSegmentSeries
    
    Returns:
    
    the lowest IP address series whose host is non-zero, or null if no such address section exists.
  - getLower
```
public abstract IPAddress 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 AddressComponent
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Specified by:
    
    getLower in interface AddressItemRange
    
    Specified by:
    
    getLower in interface IPAddressRange
    
    Specified by:
    
    getLower in interface IPAddressSegmentSeries
    
    Specified by:
    
    getLower in class Address
    
    Returns:
  - getUpper
```
public abstract IPAddress 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 AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Specified by:
    
    getUpper in interface AddressItemRange
    
    Specified by:
    
    getUpper in interface IPAddressRange
    
    Specified by:
    
    getUpper in interface IPAddressSegmentSeries
    
    Specified by:
    
    getUpper in class Address
    
    Returns:
  - reverseBits
```
public abstract IPAddress reverseBits(boolean perByte)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bits reversed.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBits in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBits in class Address
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public abstract IPAddress 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
    
    Specified by:
    
    reverseBytes in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBytes in class Address
    
    Returns:
  - reverseBytesPerSegment
```
public abstract IPAddress reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBytesPerSegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBytesPerSegment in class Address
    
    Returns:
  - reverseSegments
```
public abstract IPAddress 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
    
    Specified by:
    
    reverseSegments in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseSegments in class Address
    
    Returns:
  - iterator
```
public abstract java.util.Iterator<? extends IPAddress> iterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segment series. The resulting elements will not have an assigned prefix.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface AddressItemRange
    
    Specified by:
    
    iterator in interface IPAddressRange
    
    Specified by:
    
    iterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    iterator in class Address
    
    Returns:
  - nonZeroHostIterator
```
public abstract java.util.Iterator<? extends IPAddress> nonZeroHostIterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Similar to the prefix block iterator, but series with a host of zero are skipped.
    
    Specified by:
    
    nonZeroHostIterator in interface IPAddressSegmentSeries
    
    Returns:
  - prefixIterator
```
public abstract java.util.Iterator<? extends IPAddress> 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
    
    Specified by:
    
    prefixIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixIterator in class Address
  - prefixBlockIterator
```
public abstract java.util.Iterator<? extends IPAddress> 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
    
    Specified by:
    
    prefixBlockIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixBlockIterator in class Address
  - blockIterator
```
public abstract java.util.Iterator<? extends IPAddress> blockIterator(int segmentCount)
```
    Description copied from interface: IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    blockIterator in interface IPAddressSegmentSeries
    
    Returns:
  - sequentialBlockIterator
```
public java.util.Iterator<? extends IPAddress> sequentialBlockIterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    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 the using IPAddressSegmentSeries.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
    
    Specified by:
    
    sequentialBlockIterator in interface IPAddressSegmentSeries
    
    Returns:
  - getSequentialBlockCount
```
public java.math.BigInteger getSequentialBlockCount()
```
    Description copied from interface: IPAddressSegmentSeries
    
    provides the count of elements from the IPAddressSegmentSeries.sequentialBlockIterator(), the minimal number of sequential subseries that comprise this series
    
    Specified by:
    
    getSequentialBlockCount in interface IPAddressSegmentSeries
    
    Returns:
  - getIterable
```
public abstract java.lang.Iterable<? extends IPAddress> getIterable()
```
    Description copied from interface: AddressItemRange
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressItemRange.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponent
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Specified by:
    
    getIterable in interface AddressItemRange
    
    Specified by:
    
    getIterable in interface IPAddressRange
    
    Specified by:
    
    getIterable in interface IPAddressSegmentSeries
    
    Specified by:
    
    getIterable in class Address
    
    Returns:
    
    an object to iterate over the individual addresses represented by this object.
  - increment
```
public abstract IPAddress increment(long increment)
                             throws AddressValueException
```
    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
    
    Specified by:
    
    increment in interface IPAddressSegmentSeries
    
    Specified by:
    
    increment in class Address
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - incrementBoundary
```
public abstract IPAddress incrementBoundary(long increment)
                                     throws AddressValueException
```
    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
    
    Specified by:
    
    incrementBoundary in interface IPAddressSegmentSeries
    
    Specified by:
    
    incrementBoundary in class Address
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - getIPVersion
```
public IPAddress.IPVersion getIPVersion()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the version of this segment series
    
    Specified by:
    
    getIPVersion in interface IPAddressSegmentSeries
    
    Returns:
  - toIPv4
```
public IPv4Address toIPv4()
```
    If this address is IPv4, or can be converted to IPv4, returns that IPv4Address. Otherwise, returns null.
    
    Returns:
    
    the address
    
    See Also:
    
    isIPv4Convertible()
  - toIPv6
```
public IPv6Address toIPv6()
```
    Returns:
    
    If this address is IPv6, or can be converted to IPv6, returns that IPv6Address. Otherwise, returns null.
    
    See Also:
    
    isIPv6Convertible()
  - isIPv4Convertible
```
public abstract boolean isIPv4Convertible()
```
    Determines whether this address can be converted to IPv4, if not IPv4 already. Override this method to convert in your own way. If IPv6, the default behaviour is to convert by IPv4 mapping, see IPv6Address.isIPv4Mapped() You should also override toIPv4() to match the conversion. This method returns true for all IPv4 addresses.
    
    Returns:
  - isIPv6Convertible
```
public abstract boolean isIPv6Convertible()
```
    Determines whether an address can be converted to IPv6, if not IPv6 already. Override this method to convert in your own way. The default behaviour is to convert by IPv4 mapping, see IPv4Address.getIPv4MappedAddress() You should also override toIPv6() to match the conversion. This method returns true for all IPv6 addresses.
    
    Returns:
  - isLinkLocal
```
public abstract boolean isLinkLocal()
```
    Returns whether the address is link local, whether unicast or multicast.
    
    See Also:
    
    InetAddress.isLinkLocalAddress()
  - isLocal
```
public abstract boolean isLocal()
```
    Returns true if the address is link local, site local, organization local, administered locally, or unspecified. This includes both unicast and multicast.
    
    Specified by:
    
    isLocal in class Address
    
    Returns:
  - isUnspecified
```
public boolean isUnspecified()
```
    The unspecified address is the address that is all zeros.
    
    Returns:
  - isAnyLocal
```
public boolean isAnyLocal()
```
    Returns whether this address is the address which binds to any address on the local host. This is the address that has the value of 0, aka the unspecfied address.
    
    See Also:
    
    InetAddress.isAnyLocalAddress()
  - isLoopback
```
public abstract boolean isLoopback()
```
    See Also:
    
    InetAddress.isLoopbackAddress()
  - toUpperInetAddress
```
public java.net.InetAddress toUpperInetAddress()
```
    Converts the highest value of this address to an InetAddress. If this consists of just a single address and not a subnet, this is equivalent to toInetAddress()
  - toInetAddress
```
public java.net.InetAddress toInetAddress()
```
    Converts the lowest value of this address to an InetAddress
  - toSequentialRange
```
public abstract IPAddressSeqRange toSequentialRange()
```
    Creates a sequential range instance from the lowest and highest addresses in this subnet
    The two will represent the same set of addresses if and only if Address.isSequential() is true
    If this represents just a single address then the returned instance covers just that single address as well.
    
    Returns:
  - toSequentialRange
```
public abstract IPAddressSeqRange toSequentialRange(IPAddress other)
```
    Creates a sequential range instance from this and the given address, spanning from the lowest to the highest addresses in the two subnets If the other address is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    
    Returns:
  - matches
```
public boolean matches(IPAddressString otherString)
```
  - contains
```
public boolean contains(IPAddressSeqRange other)
```
    Description copied from interface: IPAddressRange
    
    Returns whether this range contains all addresses in the given sequential range
    
    Specified by:
    
    contains in interface IPAddressRange
    
    Returns:
  - contains
```
public boolean contains(IPAddress other)
```
    Returns whether this contains all values of the given address
    
    Specified by:
    
    contains in interface IPAddressRange
    
    Parameters:
    
    other -
    
    Returns:
  - matchesWithMask
```
public boolean matchesWithMask(IPAddress other,
                               IPAddress mask)
```
    Applies the mask to this address and then compares values with the given address
    
    Parameters:
    
    mask -
    
    other -
    
    Returns:
  - toNormalizedString
```
public static void toNormalizedString(IPAddress.IPAddressValueProvider provider,
                                      java.lang.StringBuilder builder)
```
    Allows for the creation of a normalized string without creating a full IP address object first. Instead you can implement the IPAddress.IPAddressValueProvider interface in whatever way is most efficient. The string is appended to the provided StringBuilder instance.
    
    Parameters:
    
    provider -
    
    builder -
  - toNormalizedString
```
public static java.lang.String toNormalizedString(IPAddress.IPAddressValueProvider provider)
```
    Allows for the creation of a normalized string without creating a full IP address object first. Instead you can implement the IPAddress.IPAddressValueProvider interface in whatever way is most efficient.
    
    Parameters:
    
    provider -
  - toFullString
```
public java.lang.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. Each address has a unique full string, not counting CIDR the prefix, which can give two equal addresses different strings.
    
    Specified by:
    
    toFullString in interface IPAddressSegmentSeries
  - toSubnetString
```
public java.lang.String toSubnetString()
```
    Produces a consistent subnet string that looks like 1.2.*.* or 1:2::/16 In the case of IPv4, this means that wildcards are used instead of a network prefix when a network prefix has been supplied. In the case of IPv6, when a network prefix has been supplied, the prefix will be shown and the host section will be compressed with ::.
    
    Specified by:
    
    toSubnetString in interface IPAddressSegmentSeries
  - toNormalizedWildcardString
```
public java.lang.String toNormalizedWildcardString()
```
    This produces a string similar to the normalized string but avoids the CIDR prefix. CIDR addresses will be shown with wildcards and ranges instead of using the CIDR prefix notation.
    
    Specified by:
    
    toNormalizedWildcardString in interface IPAddressSegmentSeries
  - toCanonicalWildcardString
```
public java.lang.String toCanonicalWildcardString()
```
    This produces a string similar to the canonical string but 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.
    
    Specified by:
    
    toCanonicalWildcardString in interface IPAddressSegmentSeries
  - toCompressedWildcardString
```
public java.lang.String toCompressedWildcardString()
```
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
    
    Specified by:
    
    toCompressedWildcardString in interface IPAddressSegmentSeries
  - toSQLWildcardString
```
public java.lang.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
    
    Specified by:
    
    toSQLWildcardString in interface IPAddressSegmentSeries
  - toPrefixLengthString
```
public java.lang.String toPrefixLengthString()
```
    Returns a string with a CIDR network prefix length if this address has a network prefix length. For IPv6, the host section will be compressed with ::, for IPv4 the host section will be zeros.
    
    Specified by:
    
    toPrefixLengthString in interface IPAddressSegmentSeries
    
    Returns:
  - toConvertedString
```
public java.lang.String toConvertedString()
```
    Returns a mixed string if it represents a convertible IPv4 address, returns the normalized string otherwise.
    
    Returns:
  - toUNCHostName
```
public abstract java.lang.String toUNCHostName()
```
    Generates the Microsoft UNC path component for this address
    
    Returns:
  - toReverseDNSLookupString
```
public java.lang.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
    
    Specified by:
    
    toReverseDNSLookupString in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this address is a subnet
  - toBinaryString
```
public java.lang.String toBinaryString()
```
    Writes this address as a single binary value with always the exact same number of characters
    If this section represents a range of values not corresponding to a prefix, then this is printed as a range of two hex values.
    
    Specified by:
    
    toBinaryString in interface IPAddressSegmentSeries
  - toOctalString
```
public java.lang.String toOctalString(boolean with0Prefix)
```
    Writes this address 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 not corresponding to a prefix, then this is printed as a range of two hex values.
    
    Specified by:
    
    toOctalString in interface IPAddressSegmentSeries
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions params)
```
    Constructs a string representing this address according to the given parameters
    
    Specified by:
    
    toNormalizedString in interface IPAddressSegmentSeries
    
    Parameters:
    
    params - the parameters for the address string
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - for cases in which the requested string cannot be produced, which can generally only occur with specific strings from specific subnets.
  - toStandardStrings
```
public java.lang.String[] toStandardStrings()
```
    Returns at most a few dozen string representations: -mixed (1:2:3:4:5:6:1.2.3.4) -full compressions (a:0:b:c:d:0:e:f or a::b:c:d:0:e:f or a:0:b:c:d::e:f) -full leading zeros (000a:0000:000b:000c:000d:0000:000e:000f) -all uppercase and all lowercase (a::a can be A::A) -combinations thereof
    
    Returns:
  - toAllStrings
```
public java.lang.String[] toAllStrings()
```
    Produces almost all possible string variations
    Use this method with care... a single IPv6 address can have thousands of string representations.
    Examples:
    - "::" has 1297 such variations, but only 9 are considered standard
    - "a:b:c:0:d:e:f:1" has 1920 variations, but only 12 are standard
    Variations included in this method:
    - all standard variations from toStandardStrings()
    - adding a variable number of leading zeros (::a can be ::0a, ::00a, ::000a)
    - choosing any number of zero-segments to compress (:: can be 0:0:0::0:0)
    - mixed representation of all variations (1:2:3:4:5:6:1.2.3.4)
    - all uppercase and all lowercase (a::a can be A::A)
    - all combinations of such variations
    Variations omitted from this method: mixed case of a-f, which you can easily handle yourself with String.equalsIgnoreCase
    Returns:
    
    the strings
  - toStrings
```
public java.lang.String[] toStrings(IPAddressSection.IPStringBuilderOptions options)
```
    Rather than using toAllStrings or StandardStrings, you can use this method to customize the list of strings produced for this address
  - toStandardStringCollection
```
public IPAddressPartStringCollection toStandardStringCollection()
```
  - toAllStringCollection
```
public IPAddressPartStringCollection toAllStringCollection()
```
  - toStringCollection
```
public IPAddressPartStringCollection toStringCollection(IPAddressSection.IPStringBuilderOptions options)
```
    Specified by:
    
    toStringCollection in interface IPAddressSegmentSeries
  - toAddressString
```
public IPAddressString toAddressString()
```
    Generates an IPAddressString object for this IPAddress object.
    This same IPAddress object can be retrieved from the resulting IPAddressString object using IPAddressString.getAddress()
    In general, users are intended to create IPAddress objects from IPAddressString objects, while the reverse direction is generally not all that useful.
    However, the reverse direction can be useful under certain circumstances.
    Not all IPAddressString objects can be converted to IPAddress objects, as is the case with IPAddressString objects corresponding to the types IPType.INVALID and IPType.EMPTY.
    Not all IPAddressString objects can be converted to IPAddress objects without specifying the IP version, as is the case with IPAddressString objects corresponding to the types IPType.PREFIX and IPType.ALL.
    So in the event you wish to store a collection of IPAddress objects with a collection of IPAddressString objects, and not all the IPAddressString objects can be converted to IPAddress objects, then you may wish to use a collection of only IPAddressString objects, in which case this method is useful.
    
    Overrides:
    
    toAddressString in class Address
    
    Returns:
    
    an IPAddressString object for this IPAddress.
  - toDelimitedSQLStrs
```
public static java.lang.String toDelimitedSQLStrs(java.lang.String[] strs)
```
  - getNetworkPrefixLength
```
public java.lang.Integer getNetworkPrefixLength()
```
    Description copied from interface: IPAddressDivisionSeries
    
    Returns the CIDR network prefix length of the series, or null if the series has no associated prefix length.
    Equivalent to AddressDivisionSeries.getPrefixLength(), which is the more general concept of set of address series that share the same set of leading bits. For IP addresses and sections the prefix length and the CIDR network prefix length are the same thing.
    For IP addresses and sections each individual segment has an associated prefix length which is determine by the network prefix length. The segment prefix lengths follow the pattern: null, null, ...., null, x, 0, 0, ..., 0
    For instance, an IPv4 address 1.2.3.4/16 has the network prefix length 16. The segment prefix lengths are [null, 8, 0, 0] The segment prefix lengths of 1.2.3.4/22 are [null, null, 6, 0]
    
    Specified by:
    
    getNetworkPrefixLength in interface IPAddressDivisionSeries
    
    Returns:
  - includesZeroHost
```
public boolean includesZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    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.
    
    Specified by:
    
    includesZeroHost in interface IPAddressSegmentSeries
    
    Returns:
  - includesZeroHost
```
public boolean includesZeroHost(int networkPrefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns whether all bits past the given prefix length are zero.
    
    Specified by:
    
    includesZeroHost in interface IPAddressSegmentSeries
    
    Returns:
  - toZeroHost
```
public abstract IPAddress toZeroHost(int prefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    toZeroHost in interface IPAddressSegmentSeries
    
    Returns:
  - toZeroHost
```
public abstract IPAddress toZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series with a host of zero. If the series has no prefix length, then it returns an all-zero 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 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
    
    Specified by:
    
    toZeroHost in interface IPAddressSegmentSeries
    
    Returns:
  - toMaxHost
```
public abstract IPAddress toMaxHost(int prefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    toMaxHost in interface IPAddressSegmentSeries
    
    Returns:
  - toMaxHost
```
public abstract IPAddress toMaxHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    toMaxHost in interface IPAddressSegmentSeries
    
    Returns:
  - includesMaxHost
```
public boolean includesMaxHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    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.
    
    Specified by:
    
    includesMaxHost in interface IPAddressSegmentSeries
    
    Returns:
  - includesMaxHost
```
public boolean includesMaxHost(int networkPrefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns whether all bits past the given prefix length are all ones.
    
    Specified by:
    
    includesMaxHost in interface IPAddressSegmentSeries
    
    Returns:
  - isSingleNetwork
```
public boolean isSingleNetwork()
```
    Returns true if the network section of the address spans just a single value
    For example, return true for 1.2.3.4/16 and false for 1.2-3.3.4/16
  - toPrefixBlock
```
public abstract IPAddress toPrefixBlock()
```
    Returns the subnet associated with the prefix length of this address. If this address has no prefix length, this address is returned.
    For example, if the address is 1.2.3.4/16 it returns the subnet 1.2.*.* /16
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in class Address
    
    Returns:
    
    the block of address series for the prefix length
  - toPrefixBlock
```
public abstract IPAddress toPrefixBlock(int networkPrefixLength)
                                 throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    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.
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - assignPrefixForSingleBlock
```
public IPAddress assignPrefixForSingleBlock()
```
    Returns the equivalent CIDR address with a prefix length for which the address subnet block matches the range of values in this address.
    If no such prefix length exists, returns null.
    Examples:
    1.2.3.4 returns 1.2.3.4/32
    1.2.*.* returns 1.2.0.0/16
    1.2.*.0/24 returns 1.2.0.0/16
    1.2.*.4 returns null
    1.2.252-255.* returns 1.2.252.0/22
    1.2.3.4/x returns the same address
    
    Specified by:
    
    assignPrefixForSingleBlock in interface IPAddressSegmentSeries
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignMinPrefixForBlock()
  - assignMinPrefixForBlock
```
public IPAddress assignMinPrefixForBlock()
```
    Constructs an equivalent address with the smallest CIDR prefix possible (largest network), such that the range of values are a set of subnet blocks for that prefix.
    
    Specified by:
    
    assignMinPrefixForBlock in interface IPAddressSegmentSeries
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignPrefixForSingleBlock()
  - getBlockMaskPrefixLength
```
public java.lang.Integer getBlockMaskPrefixLength(boolean network)
```
    If this address is equivalent to the mask for a CIDR prefix block, it returns that prefix length. Otherwise, it returns null. A CIDR network mask is all 1s in the network section and then all 0s in the host section. A CIDR host mask is all 0s in the network section and then all 1s in the host section. The prefix is the length of the network section. Also, keep in mind that the prefix length returned by this method is not equivalent to the prefix length used to construct this object. The prefix length used to construct indicates the network and host portion of this address. The prefix length returned here indicates the whether the value of this address can be used as a mask for the network and host portion of any other address. Therefore the two values can be different values, or one can be null while the other is not.
    
    Parameters:
    
    network - whether to check if we are a network mask or a host mask
    
    Returns:
    
    the prefix length corresponding to this mask, or null if there is no such prefix length
  - spanWithPrefixBlocks
```
public abstract IPAddress[] spanWithPrefixBlocks(IPAddress other)
                                          throws AddressConversionException
```
    Produces the list of prefix block subnets that span from this subnet to the given subnet.
    If the other address is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    The resulting array is sorted from lowest address value to highest, regardless of the size of each prefix block.
    From the list of returned subnets you can recover the original range (this and other) by converting each to IPAddressRange with toSequentialRange() and them joining them into a single range with IPAddressSeqRange.join(IPAddressSeqRange...)
    
    Parameters:
    
    other -
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - spanWithSequentialBlocks
```
public abstract IPAddress[] spanWithSequentialBlocks(IPAddress other)
                                              throws AddressConversionException
```
    Produces a list of sequential block subnets that span all values from this subnet to the given subnet. The span will cover the sequence of all addresses from the lowest address in both subnets to the highest address in both subnets.
    Individual block subnets come in the form 1-3.1-4.5.6-8, however that particular subnet is not sequential since address 1.1.5.8 is in the subnet, the next sequential address 1.1.5.9 is not in the subnet, and a higher address 1.2.5.6 is in the subnet. Blocks are sequential when the first segment with a range of values is followed by segments that span all values.
    If the other address is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    The resulting array is sorted from lowest address value to highest, regardless of the size of each prefix block.
    From the list of returned subnets you can recover the original range (this and other) by converting each to IPAddressRange with toSequentialRange() and them joining them into a single range with IPAddressSeqRange.join(IPAddressSeqRange...)
    
    Parameters:
    
    other -
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - spanWithRange
```
public abstract IPAddressSeqRange spanWithRange(IPAddress other)
                                         throws AddressConversionException
```
    Produces an IPAddressRange instance that spans this subnet to the given subnet.
    If the other address is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    
    Parameters:
    
    other -
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - mergeToPrefixBlocks
```
public abstract IPAddress[] mergeToPrefixBlocks(IPAddress... addresses)
                                         throws AddressConversionException
```
    Merges this with the list of addresses to produce the smallest list of prefix blocks
    For the smallest list of subnets use mergeToSequentialBlocks(IPAddress...).
    If any other address in the list is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6(), which can result in AddressConversionException
    The result is sorted from single address to smallest blocks to largest blocks.
    
    Parameters:
    
    addresses - the addresses to merge with this
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - mergeToSequentialBlocks
```
public abstract IPAddress[] mergeToSequentialBlocks(IPAddress... addresses)
                                             throws AddressConversionException
```
    Merges this with the list of subnets to produce the smallest list of block subnets that are sequential.
    Block subnets come in the form 1-3.1-4.5.6-8, however that subnet is not sequential since address 1.1.5.8 is in the subnet, the next sequential address 1.1.5.9 is not in the subnet, and a higher address 1.2.5.6 is in the subnet. Blocks are sequential when the first segment with a range of values is followed by segments that span all values.
    This list will eliminate overlaps to produce the smallest list of sequential block subnets, which is the same size or smaller than the list of prefix blocks produced by mergeToPrefixBlocks(IPAddress...)
    If the incoming blocks are not sequential, the result could be a longer list, since the list is divided into sequential blocks before merging.
    If any other address in the list is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6(), which can result in AddressConversionException
    The result is sorted from smallest blocks (possibly single address) to largest blocks.
    
    Parameters:
    
    addresses - the addresses to merge with this
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - intersect
```
public abstract IPAddress intersect(IPAddress other)
                             throws AddressConversionException
```
    Produces the subnet whose addresses are found in both this and the given subnet argument, or null if no such addresses.
    This is also known as the conjunction of the two sets of addresses.
    If the address is not the same version, the default conversion will be applied using toIPv4() or toIPv6(), and it that fails, AddressConversionException will be thrown.
    
    Parameters:
    
    other -
    
    Returns:
    
    the subnet containing the addresses found in both this and the given subnet
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - subtract
```
public abstract IPAddress[] subtract(IPAddress other)
                              throws AddressConversionException
```
    Subtract the given subnet from this subnet, returning an array of subnets for the result (the subnets will not be contiguous so an array is required).
    Computes the subnet difference, the set of addresses in this address subnet but not in the provided subnet. This is also known as the relative complement of the given argument in this subnet.
    If the address is not the same version, the default conversion will be applied using toIPv4() or toIPv6(), and it that fails, AddressConversionException will be thrown.
    
    Parameters:
    
    other -
    
    Returns:
    
    the difference
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - mask
```
public abstract IPAddress mask(IPAddress mask)
                        throws AddressConversionException,
                               IncompatibleAddressException
```
    Equivalent to calling mask(IPAddress, boolean) with the second argument as false.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    
    Parameters:
    
    mask -
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - mask
```
public abstract IPAddress mask(IPAddress mask,
                               boolean retainPrefix)
                        throws AddressConversionException,
                               IncompatibleAddressException
```
    Applies the given mask to all addresses represented by this IPAddress. The mask is applied to all individual addresses. Any existing prefix length is removed beforehand. If the retainPrefix argument is true, then the existing prefix length will be applied to the result.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    If this represents multiple addresses, and applying the mask to all addresses creates a set of addresses that cannot be represented as a contiguous range within each segment, then IncompatibleAddressException is thrown.
    
    Parameters:
    
    mask -
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - maskNetwork
```
public abstract IPAddress maskNetwork(IPAddress mask,
                                      int networkPrefixLength)
                               throws AddressConversionException,
                                      IncompatibleAddressException
```
    Applies the given mask to all addresses represented by this IPAddress while also applying the given prefix length at the same time.
    Any existing prefix length is removed as the mask and new prefix length is applied to all individual addresses.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    If this represents multiple addresses, and applying the mask to all addresses creates a set of addresses that cannot be represented as a contiguous range within each segment, then IncompatibleAddressException is thrown.
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - bitwiseOr
```
public abstract IPAddress bitwiseOr(IPAddress mask)
                             throws AddressConversionException,
                                    IncompatibleAddressException
```
    Equivalent to calling bitwiseOr(IPAddress, boolean) with the second argument as false.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    
    Parameters:
    
    mask -
    
    Returns:
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
  - bitwiseOr
```
public abstract IPAddress bitwiseOr(IPAddress mask,
                                    boolean retainPrefix)
                             throws AddressConversionException,
                                    IncompatibleAddressException
```
    Does the bitwise disjunction with this address. Useful when subnetting.
    The mask is applied to all individual addresses, similar to how the method mask(IPAddress, boolean) applies the bitwise conjunction. Any existing prefix length is removed beforehand. If the retainPrefix argument is true, then the existing prefix length will be applied to the result.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    If you wish to mask a portion of the network, use bitwiseOrNetwork(IPAddress, int)
    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 hostMask = address.getNetwork().getHostMask(address.getNetworkPrefixLength());//0.0.255.255 IPAddress broadcastAddress = address.bitwiseOr(hostMask); //1.2.255.255
    
    Parameters:
    
    mask -
    
    retainPrefix -
    
    Returns:
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
  - bitwiseOrNetwork
```
public abstract IPAddress bitwiseOrNetwork(IPAddress mask,
                                           int networkPrefixLength)
                                    throws AddressConversionException,
                                           IncompatibleAddressException
```
    Does the bitwise disjunction with this address. Useful when subnetting.
    If the mask is a different version than this, then the default conversion is applied to the other address first using toIPv4() or toIPv6()
    Any existing prefix length is dropped for the new prefix length and the mask is applied up to the end the new prefix length. It is similar to how the maskNetwork(IPAddress, int) method does the bitwise conjunction.
    
    Parameters:
    
    mask -
    
    networkPrefixLength - the new prefix length for the address
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - removePrefixLength
```
public abstract IPAddress removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length while zeroing out the existing host.
    If the series already has a prefix length, the bits outside the prefix become zero.
    Equivalent to calling removePrefixLength(true)
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class Address
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.removePrefixLength(boolean)
  - removePrefixLength
```
public abstract IPAddress removePrefixLength(boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class Address
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - withoutPrefixLength
```
public abstract IPAddress withoutPrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Provides the same address with no prefix. Equivalent to calling withoutPrefixLength()
    
    Specified by:
    
    withoutPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    withoutPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    withoutPrefixLength in class Address
  - adjustPrefixBySegment
```
public abstract IPAddress 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.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in class Address
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    Returns:
  - adjustPrefixBySegment
```
public abstract IPAddress 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
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in class Address
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - adjustPrefixLength
```
public abstract IPAddress adjustPrefixLength(int adjustment)
```
    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, and if the entire host address contains the zero address, then the resulting address is determined AddressNetwork.getPrefixConfiguration().
    For example, 1.2.0.0/16 adjusted by -8 becomes 1.0.0.0/8.
    1.2.0.0/16 adjusted by 8 becomes 1.2.0.0/24
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in class Address
    
    Parameters:
    
    adjustment -
    
    Returns:
  - adjustPrefixLength
```
public abstract IPAddress 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
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in class Address
    
    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
```
public abstract IPAddress 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.
    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
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class Address
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.applyPrefixLength(int)
  - setPrefixLength
```
public abstract IPAddress 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
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class Address
    
    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
```
public abstract IPAddress applyPrefixLength(int networkPrefixLength)
```
    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
    
    Specified by:
    
    applyPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in class Address
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - getMatchesSQLClause
```
public void getMatchesSQLClause(java.lang.StringBuilder builder,
                                java.lang.String sqlExpression)
```
    Returns a clause for matching this address.
    If this address is a subnet, this method will attempt to match every address in the subnet. Therefore it is much more efficient to use getNetworkSection().getStartsWithSQLClause() for a CIDR subnet.
    
    Parameters:
    
    builder -
    
    sqlExpression -
  - getMatchesSQLClause
```
public void getMatchesSQLClause(java.lang.StringBuilder builder,
                                java.lang.String sqlExpression,
                                IPAddressSQLTranslator translator)
```
    Returns a clause for matching this address.
    Similar to getMatchesSQLClause(StringBuilder builder, String sqlExpression) but allows you to tailor the SQL produced.
    
    Parameters:
    
    builder -
    
    sqlExpression -
    
    translator -

Class IPAddress

Nested Class Summary

Nested classes/interfaces inherited from class inet.ipaddr.Address

Field Summary

Fields inherited from class inet.ipaddr.Address

Method Summary

Methods inherited from class inet.ipaddr.Address

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.IPAddressSegmentSeries

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.AddressItem

Methods inherited from interface inet.ipaddr.format.IPAddressRange

Field Detail

PREFIX_LEN_SEPARATOR

DEFAULT_ADDRESS_CONVERTER

Method Detail

toHostName

toCanonicalHostName

getNetwork

getSection

getSection

getSection

getParts

getMaxSegmentValue

getNonZeroHostCount

getBytesPerSegment

getBitsPerSegment

getByteCount

getByteCount

getSegmentCount

getBitCount

getLowerNonZeroHost

getLower

getUpper

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

iterator

nonZeroHostIterator

prefixIterator

prefixBlockIterator

blockIterator

sequentialBlockIterator

getSequentialBlockCount

getIterable

increment

incrementBoundary

isIPv4

isIPv6

getIPVersion

toIPv4

toIPv6

isIPv4Convertible

isIPv6Convertible

isLinkLocal

isLocal

isUnspecified

isAnyLocal

isLoopback

toUpperInetAddress

toInetAddress

toSequentialRange

toSequentialRange

matches

contains

contains

matchesWithMask

toNormalizedString

toNormalizedString

toFullString

toSubnetString

toNormalizedWildcardString

toCanonicalWildcardString

toCompressedWildcardString