IPAddressSection

java.lang.Object
- inet.ipaddr.format.AddressDivisionGrouping
- - inet.ipaddr.format.IPAddressDivisionGrouping
  - - inet.ipaddr.IPAddressSection

All Implemented Interfaces:

AddressComponent, AddressSection, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressStringDivisionSeries, IPAddressStringDivisionSeries, java.io.Serializable, java.lang.Comparable<AddressDivisionGrouping>

Direct Known Subclasses:

IPv4AddressSection, IPv6AddressSection
```
public abstract class IPAddressSection
extends IPAddressDivisionGrouping
implements AddressSection
```
A section of an IPAddress. It is a series of individual address segments.
IPAddressSection objects are immutable. Some of the derived state is created upon demand and cached. This also makes them thread-safe. Almost all operations that can be performed on IPAddress objects can also be performed on IPAddressSection objects and vice-versa.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`IPAddressSection.IPStringBuilderOptions` This user-facing class is designed to be a clear way to create a collection of strings.
`static class`	`IPAddressSection.IPStringOptions` Represents a clear way to create a specific type of string.
`static interface`	`IPAddressSection.SegFunction<R,S>`
`static class`	`IPAddressSection.WildcardOptions`

Nested classes/interfaces inherited from class inet.ipaddr.format.IPAddressDivisionGrouping
IPAddressDivisionGrouping.Range, IPAddressDivisionGrouping.RangeList

Nested classes/interfaces inherited from class inet.ipaddr.format.AddressDivisionGrouping
AddressDivisionGrouping.StringOptions

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`IPAddressSection`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`abstract IPAddressSection`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`abstract IPAddressSection`	`applyPrefixLength(int networkPrefixLength)` Applies the given network prefix bit length.
`static int`	`bitsPerSegment(IPAddress.IPVersion version)`
`static int`	`bytesPerSegment(IPAddress.IPVersion version)`
`boolean`	`contains(IPAddressSection other)`
`int`	`getBitCount()`
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`abstract int`	`getByteIndex(int networkPrefixLength)`
`java.lang.Integer`	`getEquivalentPrefix()` Returns a prefix length for which the range of this address section can be specified only using the section's lower value and the prefix length If no such prefix exists, returns null If this address section represents a single value, returns the bit length
`java.lang.Integer`	`getHostBits()`
`abstract IPAddressSection`	`getHostSection(int networkPrefixLength)`
`abstract IPAddress.IPVersion`	`getIPVersion()`
`abstract java.lang.Iterable<? extends IPAddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract IPAddressSection`	`getLower()` If this represents an address section with ranging values, returns an address section representing the lower values of the range If this represents an address section with a single value in each segment, returns this.
`java.lang.Integer`	`getMaskPrefixLength(boolean network)` If this address section is equivalent to the mask for a CIDR prefix, it returns that prefix length.
`int`	`getMinPrefix()` Returns the smallest CIDR prefix possible (largest network), such that this address paired with that prefix represents the exact same range of addresses.
`abstract IPAddressNetwork`	`getNetwork()`
`abstract IPAddressSection`	`getNetworkSection(int networkPrefixLength)`
`abstract IPAddressSection`	`getNetworkSection(int networkPrefixLength, boolean withPrefixLength)`
`IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions options)` Get all representations of this address including this IPAddressSection.
`abstract IPAddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`abstract IPAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`IPAddressSegment`	`getSegment(int index)`
`int`	`getSegmentCount()`
`abstract int`	`getSegmentIndex(int networkPrefixLength)`
`static java.lang.Integer`	`getSegmentPrefixLength(int bitsPerSegment, int segmentPrefixedBits)` Across the address prefixes are: IPv6: (null):...:(null):(1 to 16):(0):...:(0) or IPv4: ...(null).(1 to 8).(0)...
`static java.lang.Integer`	`getSegmentPrefixLength(int bitsPerSegment, java.lang.Integer prefixLength, int segmentIndex)` Across the address prefixes are: IPv6: (null):...:(null):(1 to 16):(0):...:(0) or IPv4: ...(null).(1 to 8).(0)...
`abstract IPAddressSegment[]`	`getSegments()`
`void`	`getSegments(AddressSegment[] segs)`
`void`	`getSegments(int start, int end, AddressSegment[] segs, int destIndex)` get the segments from start to end and insert into the segs array at the the given index
`java.lang.String[]`	`getSegmentStrings()`
`void`	`getStartsWithSQLClause(java.lang.StringBuilder builder, java.lang.String expression)` This method gives you an SQL clause that allows you to search the database for the front part of an address or addresses in a given network.
`void`	`getStartsWithSQLClause(java.lang.StringBuilder builder, java.lang.String expression, IPAddressSQLTranslator translator)`
`abstract IPAddressSection`	`getUpper()` If this represents an address section with ranging values, returns an address section representing the upper values of the range If this represents an address section with a single value in each segment, returns this.
`boolean`	`isEntireAddress()`
`boolean`	`isFullRange()`
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`boolean`	`isMaskCompatibleWithRange(IPAddressSection mask, java.lang.Integer networkPrefixLength)` Returns whether the given mask and prefix combination can be used to generate a subnet.
`abstract java.util.Iterator<? extends IPAddressSection>`	`iterator()` An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values.
`abstract IPAddressSection`	`removePrefixLength()` Removes the prefix.
`abstract IPAddressSection`	`removePrefixLength(boolean zeroed)`
`abstract IPAddressSection`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`abstract IPAddressSection`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`abstract IPAddressSection`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`abstract IPAddressSection`	`reverseSegments()` Returns a new segment series with the segments reversed.
`abstract java.util.Iterator<? extends IPAddressSegment[]>`	`segmentsIterator()`
`abstract IPAddressSection`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`abstract IPAddressSection`	`setPrefixLength(int prefixLength, boolean zeroed)`
`IPAddressPartStringCollection`	`toAllStringCollection()` Use this method with care...
`java.lang.String`	`toBinaryString()` Writes this address section as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
`abstract java.lang.String`	`toCanonicalWildcardString()` This produces a string similar to the canonical string and avoids the CIDR prefix.
`abstract java.lang.String`	`toCompressedString()` This produces the shortest valid string.
`abstract java.lang.String`	`toCompressedWildcardString()` This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
`IPAddressPartStringCollection`	`toDatabaseSearchStringCollection()` Returns a set of strings for search the standard string representations in a database -compress the largest compressible segments or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f) -upper/lowercase is not considered because many databases are case-insensitive
`abstract 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.
`java.lang.String`	`toHexString(boolean with0xPrefix)` Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`IPAddressSection`	`toMinPrefixedEquivalent()` Constructs an equivalent address section with the smallest CIDR prefix length possible (largest network), such that the address represents the exact same range of addresses.
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions stringOptions)`
`static java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions opts, IPAddressStringDivisionSeries section)`
`abstract java.lang.String`	`toNormalizedWildcardString()` This produces a string similar to the normalized string and avoids the CIDR prefix.
`java.lang.String`	`toOctalString(boolean with0Prefix)` Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`IPAddressSection`	`toPrefixedEquivalent()` Returns the CIDR address section for which the range of addresses in this section is specified using just a single value and a prefix length in the returned section.
`abstract java.lang.String`	`toPrefixLengthString()` Returns a string with a CIDR prefix length if this section has a network prefix length.
`abstract 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
`abstract java.lang.String`	`toSQLWildcardString()` This is the same as the string from toNormalizedWildcardString except that: -it uses IPAddress.SEGMENT_SQL_WILDCARD instead of IPAddress.SEGMENT_WILDCARD -it uses IPAddress.SEGMENT_SQL_SINGLE_WILDCARD
`IPAddressPartStringCollection`	`toStandardStringCollection()` Returns at most a couple dozen string representations: -mixed (1:2:3:4:5:6:1.2.3.4) -upper and lower case -full compressions or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f or a:0:b:c:d::e:f) -full leading zeros (000a:0000:000b:000c:000d:0000:000e:000f) -combinations thereof
`java.lang.String`	`toString()`
`abstract IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions options)`
`abstract java.lang.String`	`toSubnetString()` Produces a consistent subnet string.

Methods inherited from class inet.ipaddr.format.IPAddressDivisionGrouping
equals, getDivision, getNetworkPrefixLength, getPrefixLength, getZeroRangeSegments, getZeroSegments, isMore, isMultipleByNetworkPrefix, isMultipleByPrefix, isPrefixed, isRangeEquivalentToPrefix

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping
compareTo, getBytes, getBytes, getCount, getDivisionCount, getUpperBytes, getUpperBytes, hashCode, isMultiple, isRangeEquivalent, isZero

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

Methods inherited from interface inet.ipaddr.AddressSection
contains

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getBitsPerSegment, getBytesPerSegment, toCanonicalString

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getDivision, getPrefixLength, isMore, isMultipleByPrefix, isPrefixed, isRangeEquivalentToPrefix

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

Methods inherited from interface inet.ipaddr.AddressComponent
toNormalizedString

Methods inherited from interface inet.ipaddr.format.AddressItem
getBytes, getBytes, getCount, getUpperBytes, getUpperBytes, isMultiple, isZero

- Method Detail
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class AddressDivisionGrouping
    
    Returns:
    
    the number of bits in this item
  - getByteCount
```
public int getByteCount()
```
    Description copied from interface: AddressComponent
    
    returns the number of bytes in each of the address components represented by this instance
    
    Specified by:
    
    getByteCount in interface AddressComponent
    
    Returns:
  - bitsPerSegment
```
public static int bitsPerSegment(IPAddress.IPVersion version)
```
  - bytesPerSegment
```
public static int bytesPerSegment(IPAddress.IPVersion version)
```
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - getIPVersion
```
public abstract IPAddress.IPVersion getIPVersion()
```
  - getByteIndex
```
public abstract int getByteIndex(int networkPrefixLength)
```
  - getSegmentIndex
```
public abstract int getSegmentIndex(int networkPrefixLength)
```
  - getNetworkSection
```
public abstract IPAddressSection getNetworkSection(int networkPrefixLength,
                                                   boolean withPrefixLength)
```
  - getNetworkSection
```
public abstract IPAddressSection getNetworkSection(int networkPrefixLength)
```
  - getHostSection
```
public abstract IPAddressSection getHostSection(int networkPrefixLength)
```
  - getMaskPrefixLength
```
public java.lang.Integer getMaskPrefixLength(boolean network)
```
    If this address section is equivalent to the mask for a CIDR prefix, it returns that prefix length. Otherwise, it returns null. A CIDR network mask is an address with all 1s in the network section and then all 0s in the host section. A CIDR host mask is an address with all 0s in the network section and then all 1s in the host section. The prefix length 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. This method applies only to the lower value of the range if this section represents multiple values.
    
    Parameters:
    
    network - whether to check for a network mask or a host mask
    
    Returns:
    
    the prefix length corresponding to this mask, or null if this address is not a CIDR prefix mask
  - getHostBits
```
public java.lang.Integer getHostBits()
```
  - getSegmentPrefixLength
```
public static java.lang.Integer getSegmentPrefixLength(int bitsPerSegment,
                                                       java.lang.Integer prefixLength,
                                                       int segmentIndex)
```
    Across the address prefixes are: IPv6: (null):...:(null):(1 to 16):(0):...:(0) or IPv4: ...(null).(1 to 8).(0)...
  - getSegmentPrefixLength
```
public static java.lang.Integer getSegmentPrefixLength(int bitsPerSegment,
                                                       int segmentPrefixedBits)
```
    Across the address prefixes are: IPv6: (null):...:(null):(1 to 16):(0):...:(0) or IPv4: ...(null).(1 to 8).(0)...
  - getNetwork
```
public abstract IPAddressNetwork getNetwork()
```
  - getSegmentCount
```
public int getSegmentCount()
```
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
  - getSegment
```
public IPAddressSegment getSegment(int index)
```
    Specified by:
    
    getSegment in interface AddressSegmentSeries
  - contains
```
public boolean contains(IPAddressSection other)
```
    Parameters:
    
    other -
    
    Returns:
    
    whether this subnet contains the given address section
  - isFullRange
```
public boolean isFullRange()
```
    Specified by:
    
    isFullRange in interface AddressItem
    
    Overrides:
    
    isFullRange in class AddressDivisionGrouping
    
    Returns:
    
    whether this address item represents all possible values attainable by an address item of this type.
  - isMaskCompatibleWithRange
```
public boolean isMaskCompatibleWithRange(IPAddressSection mask,
                                         java.lang.Integer networkPrefixLength)
```
    Returns whether the given mask and prefix combination can be used to generate a subnet. See IPAddress#isMaskCompatibleWithRange(IPAddress, Integer)
    
    Parameters:
    
    mask -
    
    networkPrefixLength -
    
    Returns:
  - applyPrefixLength
```
public abstract IPAddressSection applyPrefixLength(int networkPrefixLength)
                                            throws AddressTypeException
```
    Applies the given network prefix bit length.
    
    Specified by:
    
    applyPrefixLength in interface AddressSection
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
    
    Throws:
    
    AddressTypeException
  - toPrefixedEquivalent
```
public IPAddressSection toPrefixedEquivalent()
```
    Returns the CIDR address section for which the range of addresses in this section is specified using just a single value and a prefix length in the returned section. Otherwise, returns null. If this address represents just a single address, this is returned.
    
    Returns:
  - toMinPrefixedEquivalent
```
public IPAddressSection toMinPrefixedEquivalent()
```
    Constructs an equivalent address section with the smallest CIDR prefix length possible (largest network), such that the address represents the exact same range of addresses.
    
    Returns:
  - removePrefixLength
```
public abstract IPAddressSection removePrefixLength(boolean zeroed)
```
  - removePrefixLength
```
public abstract IPAddressSection removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix. When the series already had a prefix, the bits previously not within the prefix are zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixBySegment
```
public IPAddressSection adjustPrefixBySegment(boolean nextSegment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary. When prefix length is increased, the bits moved within the prefix are zero.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
public abstract IPAddressSection adjustPrefixLength(int adjustment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment. When prefix length is increased, the bits moved within the prefix become zero. When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - setPrefixLength
```
public abstract IPAddressSection setPrefixLength(int prefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length. When the series already had a prefix, and the prefix length is increased, the bits moved within the prefix are zero. When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSection
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - setPrefixLength
```
public abstract IPAddressSection setPrefixLength(int prefixLength,
                                                 boolean zeroed)
```
  - getMinPrefix
```
public int getMinPrefix()
```
    Returns the smallest CIDR prefix possible (largest network), such that this address paired with that prefix represents the exact same range of addresses.
    
    Specified by:
    
    getMinPrefix in interface AddressDivisionSeries
    
    Overrides:
    
    getMinPrefix in class AddressDivisionGrouping
    
    Returns:
    
    See Also:
    
    IPAddressDivision.getMaskPrefixLength(boolean)
  - getEquivalentPrefix
```
public java.lang.Integer getEquivalentPrefix()
```
    Returns a prefix length for which the range of this address section can be specified only using the section's lower value and the prefix length If no such prefix exists, returns null If this address section represents a single value, returns the bit length
    
    Specified by:
    
    getEquivalentPrefix in interface AddressDivisionSeries
    
    Overrides:
    
    getEquivalentPrefix in class IPAddressDivisionGrouping
    
    Returns:
    
    the prefix length or null
  - getLower
```
public abstract IPAddressSection getLower()
```
    If this represents an address section with ranging values, returns an address section representing the lower values of the range If this represents an address section with a single value in each segment, returns this.
    
    Specified by:
    
    getLower in interface AddressComponent
    
    Specified by:
    
    getLower in interface AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Returns:
  - getUpper
```
public abstract IPAddressSection getUpper()
```
    If this represents an address section with ranging values, returns an address section representing the upper values of the range If this represents an address section with a single value in each segment, returns this.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Returns:
  - reverseSegments
```
public abstract IPAddressSection reverseSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the segments reversed. This does not throw AddressTypeException.
    
    Specified by:
    
    reverseSegments in interface AddressSection
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    Returns:
  - reverseBits
```
public abstract IPAddressSection 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 AddressSection
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public abstract IPAddressSection 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 AddressSection
    
    Specified by:
    
    reverseBytes in interface AddressSegmentSeries
    
    Returns:
  - reverseBytesPerSegment
```
public abstract IPAddressSection reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSection
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
public abstract IPAddressSegment[] getSegments()
```
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Returns:
    
    an array containing the segments
  - getSection
```
public abstract 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 AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
public abstract 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 AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
public void getSegments(AddressSegment[] segs)
```
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(int start,
                        int end,
                        AddressSegment[] segs,
                        int destIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    get the segments from start to end and insert into the segs array at the the given index
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getIterable
```
public abstract java.lang.Iterable<? extends IPAddressSection> getIterable()
```
    Description copied from interface: AddressComponent
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponent.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponent
    
    Specified by:
    
    getIterable in interface AddressSection
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Returns:
  - iterator
```
public abstract java.util.Iterator<? extends IPAddressSection> iterator()
```
    Description copied from interface: AddressComponent
    
    An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values. Call AddressItem.isMultiple() to determine if this instance represents multiple. This method iterates through the individual elements.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Returns:
  - segmentsIterator
```
public abstract java.util.Iterator<? extends IPAddressSegment[]> segmentsIterator()
```
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
  - isEntireAddress
```
public boolean isEntireAddress()
```
  - getSegmentStrings
```
public java.lang.String[] getSegmentStrings()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class AddressDivisionGrouping
  - toFullString
```
public abstract 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.
  - toCompressedString
```
public abstract java.lang.String toCompressedString()
```
    This produces the shortest valid string. For subnets the string will not have wildcards in host segments (there will be zeros instead), only in network segments.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Returns:
  - toPrefixLengthString
```
public abstract java.lang.String toPrefixLengthString()
```
    Returns a string with a CIDR prefix length if this section has a network prefix length. For IPv6, the host section will be compressed with ::, for IPv4 the host section will be zeros.
    
    Returns:
  - toSubnetString
```
public abstract java.lang.String toSubnetString()
```
    Produces a consistent subnet string. In the case of IPv4, this means that wildcards are used instead of a network prefix. In the case of IPv6, a prefix will be used and the host section will be compressed with ::.
  - toNormalizedWildcardString
```
public abstract java.lang.String toNormalizedWildcardString()
```
    This produces a string similar to the normalized string and avoids the CIDR prefix. CIDR addresses will be shown with wildcards and ranges instead of using the CIDR prefix notation.
  - toCanonicalWildcardString
```
public abstract java.lang.String toCanonicalWildcardString()
```
    This produces a string similar to the canonical string and avoids the CIDR prefix. Addresses with a network prefix length will be shown with wildcards and ranges instead of using the CIDR prefix length notation. IPv6 addresses will be compressed according to the canonical representation.
  - toCompressedWildcardString
```
public abstract java.lang.String toCompressedWildcardString()
```
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
  - toSQLWildcardString
```
public abstract java.lang.String toSQLWildcardString()
```
    This is the same as the string from toNormalizedWildcardString except that: -it uses IPAddress.SEGMENT_SQL_WILDCARD instead of IPAddress.SEGMENT_WILDCARD -it uses IPAddress.SEGMENT_SQL_SINGLE_WILDCARD
  - toReverseDNSLookupString
```
public abstract 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
    
    Returns:
  - toBinaryString
```
public java.lang.String toBinaryString()
```
    Writes this address section as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
  - toOctalString
```
public java.lang.String toOctalString(boolean with0Prefix)
```
    Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix. For IPv4 there are 8 hex characters, for IPv6 there are 32 hex characters. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
  - toHexString
```
public java.lang.String toHexString(boolean with0xPrefix)
```
    Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix. For IPv4 there are 8 hex characters, for IPv6 there are 32 hex characters. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions stringOptions)
```
  - toNormalizedString
```
public static java.lang.String toNormalizedString(IPAddressSection.IPStringOptions opts,
                                                  IPAddressStringDivisionSeries section)
```
  - toStandardStringCollection
```
public IPAddressPartStringCollection toStandardStringCollection()
```
    Returns at most a couple dozen string representations: -mixed (1:2:3:4:5:6:1.2.3.4) -upper and lower case -full compressions or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f or a:0:b:c:d::e:f) -full leading zeros (000a:0000:000b:000c:000d:0000:000e:000f) -combinations thereof
    
    Returns:
  - toAllStringCollection
```
public IPAddressPartStringCollection toAllStringCollection()
```
    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 -choosing specific segments for full leading zeros (::a:b can be ::000a:b, ::a:000b, or ::000a:000b) -choosing which zero-segments to compress (0:0:a:: can be ::a:0:0:0:0:0 or 0:0:a::) -mixed representation (1:2:3:4:5:6:1.2.3.4) -all combinations of such variations Variations omitted from this method: -mixed case of a-f, which you can easily handle yourself with String.equalsIgnoreCase -adding a variable number of leading zeros (::a can be ::0a, ::00a, ::000a) -choosing any number of zero-segments anywhere to compress (:: can be 0:0:0::0:0)
    
    Returns:
  - toDatabaseSearchStringCollection
```
public IPAddressPartStringCollection toDatabaseSearchStringCollection()
```
    Returns a set of strings for search the standard string representations in a database -compress the largest compressible segments or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f) -upper/lowercase is not considered because many databases are case-insensitive
    
    Returns:
  - toStringCollection
```
public abstract IPAddressPartStringCollection toStringCollection(IPAddressSection.IPStringBuilderOptions options)
```
  - getParts
```
public IPAddressStringDivisionSeries[] getParts(IPAddressSection.IPStringBuilderOptions options)
```
    Get all representations of this address including this IPAddressSection. This includes:
    - alternative segment groupings expressed as IPAddressDivisionGrouping
    - conversions to IPv6, and alternative representations of those IPv6 addresses
    Parameters:
    
    options -
    
    Returns:
  - getStartsWithSQLClause
```
public void getStartsWithSQLClause(java.lang.StringBuilder builder,
                                   java.lang.String expression)
```
    This method gives you an SQL clause that allows you to search the database for the front part of an address or addresses in a given network. This is not as simple as it sounds, because the same address can be written in different ways (especially for IPv6) and in addition, addresses in the same network can have different beginnings (eg 1.0.0.0/7 are all addresses from 0.0.0.0 to 1.255.255.255), so you can see they start with both 1 and 0. You can reduce the number of possible beginnings by choosing a segment boundary for the network prefix. The SQL produced works for MySQL. For a different database type, use getStartsWithSQLClause(StringBuilder, String, IPAddressSQLTranslator)
    
    Parameters:
    
    builder -
    
    expression - the expression that must match the condition, whether a column name or other
  - getStartsWithSQLClause
```
public void getStartsWithSQLClause(java.lang.StringBuilder builder,
                                   java.lang.String expression,
                                   IPAddressSQLTranslator translator)
```

Nested classes/interfaces inherited from class inet.ipaddr.format.IPAddressDivisionGrouping

Nested classes/interfaces inherited from class inet.ipaddr.format.AddressDivisionGrouping

Methods inherited from class inet.ipaddr.format.IPAddressDivisionGrouping

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.AddressSection

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressItem

getBitCount

getByteCount

bitsPerSegment

bytesPerSegment

isIPv4

isIPv6

getIPVersion

getByteIndex

getSegmentIndex

getNetworkSection

getNetworkSection

getHostSection

getMaskPrefixLength

getHostBits

getSegmentPrefixLength

getSegmentPrefixLength

getNetwork

getSegmentCount

getSegment

contains

isFullRange

isMaskCompatibleWithRange

applyPrefixLength

toPrefixedEquivalent

toMinPrefixedEquivalent

removePrefixLength

removePrefixLength

adjustPrefixBySegment

adjustPrefixLength

setPrefixLength

setPrefixLength

getMinPrefix

getEquivalentPrefix

getLower

getUpper

reverseSegments

reverseBits

reverseBytes

reverseBytesPerSegment

getSegments

getSection

getSection

getSegments

getSegments

getIterable

iterator

segmentsIterator

isEntireAddress

getSegmentStrings

toString

toFullString

toCompressedString

toPrefixLengthString

toSubnetString

toNormalizedWildcardString

toCanonicalWildcardString

toCompressedWildcardString

toSQLWildcardString

toReverseDNSLookupString

toBinaryString

toOctalString

toHexString

toNormalizedString

toNormalizedString

toStandardStringCollection

toAllStringCollection

toDatabaseSearchStringCollection

toStringCollection

getParts