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, IPAddressSegmentSeries, java.io.Serializable, java.lang.Comparable<AddressDivisionGrouping>

Direct Known Subclasses:

IPv4AddressSection, IPv6AddressSection
```
public abstract class IPAddressSection
extends IPAddressDivisionGrouping
implements IPAddressSegmentSeries, 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 prefix length to create a new segment series.
`IPAddressSection`	`assignMinPrefixForBlock()` Constructs an equivalent address section with the smallest CIDR prefix possible (largest network), such that the range of values are a set of subnet blocks for that prefix.
`IPAddressSection`	`assignPrefixForSingleBlock()` Returns the equivalent CIDR address section with a prefix length for which the subnet block for that prefix matches the range of values in this section.
`static int`	`bitsPerSegment(IPAddress.IPVersion version)`
`static int`	`bytesPerSegment(IPAddress.IPVersion version)`
`boolean`	`contains(IPAddressSection other)`
`int`	`getBitCount()`
`java.lang.Integer`	`getBlockMaskPrefixLength(boolean network)` If this address section is equivalent to the mask for a CIDR prefix block, it returns that prefix length.
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`java.math.BigInteger`	`getCountImpl()`
`java.lang.Integer`	`getHostBitCount()`
`java.lang.Integer`	`getHostSegmentCount()`
`abstract java.lang.Iterable<? extends IPAddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract IPAddressSection`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`abstract IPAddressSection`	`getLowerNonZeroHost()` Similar to `IPAddressSegmentSeries.getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`int`	`getMinPrefixLengthForBlock()` Returns the smallest CIDR prefix length possible (largest network) for which this includes the block of address sections for that prefix.
`java.lang.Integer`	`getNetworkSegmentCount()`
`java.math.BigInteger`	`getNonZeroHostCount()` Gets the count of single value series that this series may represent.
`IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions options)` Get all representations of this address including this IPAddressSection.
`java.lang.Integer`	`getPrefixLengthForSingleBlock()` Returns a prefix length for which the range of this address section matches the the block of addresses for that prefix.
`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)` Returns the segment from this series at the given index.
`int`	`getSegmentCount()` Returns the number of segments in this series.
`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)...
`void`	`getSegments(AddressSegment[] segs)` Copies the existing segments into the given array.
`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()` Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
`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 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`	`includesZeroHost()`
`boolean`	`isEntireAddress()`
`boolean`	`isFullRange()`
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`abstract java.util.Iterator<? extends IPAddressSection>`	`iterator()` Iterates through the individual segment series.
`abstract java.util.Iterator<? extends IPAddressSection>`	`nonZeroHostIterator()`
`abstract IPAddressSection`	`removePrefixLength()` Removes the prefix length.
`abstract IPAddressSection`	`removePrefixLength(boolean zeroed)` Removes the prefix length.
`abstract IPAddressSection`	`reverseBits(boolean perByte)` Returns a new series which has 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 IPAddressSection`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`abstract IPAddressSection`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`IPAddressPartStringCollection`	`toAllStringCollection()` Use this method with care...
`java.lang.String`	`toBinaryString()` Writes this IP address segment series as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
`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
`java.lang.String`	`toHexString(boolean with0xPrefix)` Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions stringOptions)` Creates a customized string from this series.
`static java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions opts, IPAddressStringDivisionSeries section)`
`java.lang.String`	`toOctalString(boolean with0Prefix)` Writes this IP address segment series as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix.
`abstract IPAddressSection`	`toPrefixBlock()` If this series has a prefix length, returns the subnet block for that prefix.
`abstract IPAddressSection`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`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()`

Methods inherited from class inet.ipaddr.format.IPAddressDivisionGrouping
equals, getDivision, getNetwork, getNetworkPrefixLength, getPrefixLength, getZeroRangeSegments, getZeroSegments, isMore, isPrefixBlock, isPrefixed, isSinglePrefixBlock

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping
compareTo, getBytes, getBytes, getCount, getDivisionCount, getDivisionStrings, getUpperBytes, getUpperBytes, getUpperValue, getValue, hashCode, isMultiple, 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, toCompressedString

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getDivision, getDivisionStrings, getPrefixLength, getUpperValue, getValue, isMore, isPrefixBlock, isPrefixed, isSinglePrefixBlock

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)
```
  - getNonZeroHostCount
```
public java.math.BigInteger getNonZeroHostCount()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Gets the count of single value series that this series may represent. If excludeZeroHosts is true, the count excludes series whose host is zero. If this address series has no range of values, then there is only one such address. If this has no CIDR network prefix length, then it is equivalent to AddressItem.getCount().
    
    Specified by:
    
    getNonZeroHostCount in interface IPAddressSegmentSeries
    
    Returns:
  - getCountImpl
```
public java.math.BigInteger getCountImpl()
```
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - getBlockMaskPrefixLength
```
public java.lang.Integer getBlockMaskPrefixLength(boolean network)
```
    If this address section is equivalent to the mask for a CIDR prefix block, 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 there is no such prefix length
  - getNetworkSegmentCount
```
public java.lang.Integer getNetworkSegmentCount()
```
  - getHostSegmentCount
```
public java.lang.Integer getHostSegmentCount()
```
  - getHostBitCount
```
public java.lang.Integer getHostBitCount()
```
  - 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)...
  - getSegmentCount
```
public int getSegmentCount()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of segments in this series.
    
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
    
    Returns:
  - getSegment
```
public IPAddressSegment getSegment(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segment from this series at the given index.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Specified by:
    
    getSegment in interface IPAddressSegmentSeries
    
    Returns:
  - 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.
  - applyPrefixLength
```
public abstract IPAddressSection applyPrefixLength(int networkPrefixLength)
                                            throws PrefixLenException
```
    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.
    With some address types, the bits moved outside the prefix will become zero in the returned series.
    
    Specified by:
    
    applyPrefixLength in interface AddressSection
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - toPrefixBlock
```
public abstract IPAddressSection toPrefixBlock()
```
    Description copied from interface: IPAddressSegmentSeries
    
    If this series has a prefix length, returns the subnet block for that prefix. If this series has no prefix length, this series is returned.
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Returns:
    
    the subnet block for the prefix length
  - toPrefixBlock
```
public abstract IPAddressSection toPrefixBlock(int networkPrefixLength)
```
    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:
  - assignPrefixForSingleBlock
```
public IPAddressSection assignPrefixForSingleBlock()
```
    Returns the equivalent CIDR address section with a prefix length for which the subnet block for that prefix matches the range of values in this section.
    If no such prefix length exists, returns null.
    If this address represents just a single address, "this" is returned.
    
    Specified by:
    
    assignPrefixForSingleBlock in interface IPAddressSegmentSeries
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignMinPrefixForBlock()
  - assignMinPrefixForBlock
```
public IPAddressSection assignMinPrefixForBlock()
```
    Constructs an equivalent address section 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()
  - includesZeroHost
```
public boolean includesZeroHost()
```
    Overrides:
    
    includesZeroHost in class IPAddressDivisionGrouping
  - removePrefixLength
```
public abstract IPAddressSection removePrefixLength(boolean zeroed)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Removes the prefix length. If zeroed is false, the bits that were host bits do not become zero, unlike IPAddressSegmentSeries.removePrefixLength()
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Returns:
  - removePrefixLength
```
public abstract IPAddressSection removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    If the series already has a prefix length, the bits previously not within the prefix become zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    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 become zero. When a prefix length is decreased, whether the bits moved outside the prefix become zero is dependent on the address type.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    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. When a prefix length is decreased, whether the bits moved outside the prefix become zero is dependent on the address type.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Returns:
  - setPrefixLength
```
public abstract IPAddressSection 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.
    When a prefix length is decreased, whether the bits moved outside the prefix become zero is dependent on the address type.
    
    Specified by:
    
    setPrefixLength in interface AddressSection
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.applyPrefixLength(int)
  - setPrefixLength
```
public abstract IPAddressSection setPrefixLength(int prefixLength,
                                                 boolean zeroed)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Sets the prefix length.
    If zeroed is true, and this series has a prefix length, and the prefix length is increased, the bits moved within the prefix become zero. When a prefix length is decreased, whether the bits moved outside the prefix become zero is dependent on the address type.
    When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Returns:
  - getMinPrefixLengthForBlock
```
public int getMinPrefixLengthForBlock()
```
    Returns the smallest CIDR prefix length possible (largest network) for which this includes the block of address sections for that prefix.
    
    Specified by:
    
    getMinPrefixLengthForBlock in interface AddressDivisionSeries
    
    Overrides:
    
    getMinPrefixLengthForBlock in class AddressDivisionGrouping
    
    Returns:
    
    See Also:
    
    IPAddressDivision.getBlockMaskPrefixLength(boolean)
  - getPrefixLengthForSingleBlock
```
public java.lang.Integer getPrefixLengthForSingleBlock()
```
    Returns a prefix length for which the range of this address section matches the the block of addresses for that prefix.
    If no such prefix exists, returns null
    If this address section represents a single value, returns the bit length
    
    Specified by:
    
    getPrefixLengthForSingleBlock in interface AddressDivisionSeries
    
    Overrides:
    
    getPrefixLengthForSingleBlock in class IPAddressDivisionGrouping
    
    Returns:
    
    the prefix length or null
  - getLowerNonZeroHost
```
public abstract IPAddressSection 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 IPAddressSection 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 AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Specified by:
    
    getLower in interface IPAddressSegmentSeries
    
    Returns:
  - getUpper
```
public abstract IPAddressSection 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 AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Specified by:
    
    getUpper in interface IPAddressSegmentSeries
    
    Returns:
  - reverseSegments
```
public abstract IPAddressSection 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 AddressSection
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    Specified by:
    
    reverseSegments in interface IPAddressSegmentSeries
    
    Returns:
  - reverseBits
```
public abstract IPAddressSection reverseBits(boolean perByte)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns a new series which has the bits reversed.
    If this has an associated prefix length, then the prefix length is dropped in the reversed series.
    If this represents a range of values that cannot be reversed, because reversing the range results in a set of addresses that cannot be described by a range, then this throws IncompatibleAddressException. In such cases you can call IPAddressSegmentSeries.iterator(), IPAddressSegmentSeries.getLower(), IPAddressSegmentSeries.getUpper() or some other method to transform the address into an address representing a single value before reversing.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSection
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBits in interface IPAddressSegmentSeries
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the address 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
    
    Specified by:
    
    reverseBytes in interface IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    reverseBytesPerSegment in interface IPAddressSegmentSeries
    
    Returns:
  - 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
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    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
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Returns:
  - getSegments
```
public void getSegments(AddressSegment[] segs)
```
    Description copied from interface: AddressSegmentSeries
    
    Copies the existing segments into the given array. The array size should be at least as large as AddressSegmentSeries.getSegmentCount()
    
    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
    
    Parameters:
    
    start - the first segment index from this series to be included
    
    end - the segment index after first to be excluded
    
    segs - the target array
    
    destIndex - where to insert the segments in the segs array
  - 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
    
    Specified by:
    
    getIterable in interface IPAddressSegmentSeries
    
    Returns:
  - nonZeroHostIterator
```
public abstract java.util.Iterator<? extends IPAddressSection> nonZeroHostIterator()
```
    Specified by:
    
    nonZeroHostIterator in interface IPAddressSegmentSeries
  - iterator
```
public abstract java.util.Iterator<? extends IPAddressSection> 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 AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface IPAddressSegmentSeries
    
    Returns:
  - isEntireAddress
```
public boolean isEntireAddress()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class AddressDivisionGrouping
  - getSegmentStrings
```
public java.lang.String[] getSegmentStrings()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
    
    Specified by:
    
    getSegmentStrings in interface AddressSegmentSeries
    
    Returns:
  - toBinaryString
```
public java.lang.String toBinaryString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Writes this IP address segment series as a single binary value with always the exact same number of characters If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Specified by:
    
    toBinaryString in interface IPAddressSegmentSeries
  - toOctalString
```
public java.lang.String toOctalString(boolean with0Prefix)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Writes this IP address segment series as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Specified by:
    
    toOctalString in interface IPAddressSegmentSeries
  - toHexString
```
public java.lang.String toHexString(boolean with0xPrefix)
```
    Description copied from interface: AddressComponent
    
    Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
    If this component represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    For instance, for IPv4 addresses there are 8 hex characters, for IPv6 addresses there are 32 hex characters.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions stringOptions)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Creates a customized string from this series.
    
    Specified by:
    
    toNormalizedString in interface IPAddressSegmentSeries
    
    Returns:
  - 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:
  - 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.IPAddressSegmentSeries

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

getNonZeroHostCount

getCountImpl

isIPv4

isIPv6

getBlockMaskPrefixLength

getNetworkSegmentCount

getHostSegmentCount

getHostBitCount

getSegmentPrefixLength

getSegmentCount

getSegment

contains

isFullRange

applyPrefixLength

toPrefixBlock

toPrefixBlock

assignPrefixForSingleBlock

assignMinPrefixForBlock

includesZeroHost

removePrefixLength

removePrefixLength

adjustPrefixBySegment

adjustPrefixLength

setPrefixLength

setPrefixLength

getMinPrefixLengthForBlock

getPrefixLengthForSingleBlock

getLowerNonZeroHost

getLower

getUpper

reverseSegments

reverseBits

reverseBytes

reverseBytesPerSegment

getSection

getSection

getSegments

getSegments

getIterable

nonZeroHostIterator

iterator

isEntireAddress

toString

getSegmentStrings

toBinaryString

toOctalString

toHexString

toNormalizedString

toNormalizedString

toStandardStringCollection

toAllStringCollection

toDatabaseSearchStringCollection

getParts

getStartsWithSQLClause

getStartsWithSQLClause