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
`abstract IPAddressSection`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`IPAddressSection`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` 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`	`adjustPrefixLength(int adjustment, boolean zeroed)` 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(AddressSection other)` Determines if one section contains another.
`boolean`	`containsPrefixBlock(int prefixLength)` Returns whether the values of this division grouping contain the prefix block for the given prefix length
`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()`
`IPAddressSegment`	`getDivision(int index)`
`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`	`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 IPAddressSection`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this.
`boolean`	`isEntireAddress()`
`boolean`	`isFullRange()`
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`boolean`	`isSingleNetwork()`
`abstract java.util.Iterator<? extends IPAddressSection>`	`iterator()` Iterates through the individual segment series.
`boolean`	`matchesWithMask(IPAddressSection other, IPAddressSection mask)` Applies the mask to this address section and then compares values with the given address section
`abstract java.util.Iterator<? extends IPAddressSection>`	`nonZeroHostIterator()`
`abstract java.util.Iterator<? extends IPAddressSection>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`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.
`abstract IPAddressSection`	`toMaxHost()` Returns the segment series with a host of all ones.
`abstract IPAddressSection`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`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()`
`abstract IPAddressSection`	`toZeroHost()` Returns the segment series with a host of zero.
`abstract IPAddressSection`	`toZeroHost(int prefixLength)` Produces the series with host values of 0 for the given prefix length.

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

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping
compareTo, getBytes, getBytes, getCount, getDivisionCount, getDivisionStrings, getPrefixCount, getUpperBytes, getUpperBytes, getUpperValue, getValue, hashCode, includesMax, includesZero, isMax, isMultiple, isZero

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

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

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
containsSinglePrefixBlock, getDivisionStrings, getPrefixCount, 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, includesMax, includesZero, isMax, isMultiple, isZero

- Method Detail
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class AddressDivisionGrouping
    
    Returns:
    
    the number of bits comprising this address 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:
  - getDivision
```
public IPAddressSegment getDivision(int index)
```
    Specified by:
    
    getDivision in interface AddressDivisionSeries
    
    Specified by:
    
    getDivision in interface AddressStringDivisionSeries
    
    Specified by:
    
    getDivision in interface IPAddressStringDivisionSeries
    
    Overrides:
    
    getDivision in class IPAddressDivisionGrouping
    
    Returns:
    
    the given division in this series. The first is at index 0.
  - containsPrefixBlock
```
public boolean containsPrefixBlock(int prefixLength)
```
    Description copied from class: AddressDivisionGrouping
    
    Returns whether the values of this division grouping contain the prefix block for the given prefix length
    
    Specified by:
    
    containsPrefixBlock in interface AddressDivisionSeries
    
    Overrides:
    
    containsPrefixBlock in class IPAddressDivisionGrouping
    
    Returns:
  - contains
```
public boolean contains(AddressSection other)
```
    Description copied from interface: AddressSection
    
    Determines if one section contains another. Sections must have the same number of segments to be comparable. For sections which are aware of their position in an address (IPv6 and MAC), their respective positions must match to be comparable.
    
    Specified by:
    
    contains in interface AddressSection
    
    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, or in other words, both includesZero() and includesMax() return true
  - toZeroHost
```
public abstract IPAddressSection 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:
  - toZeroHost
```
public abstract IPAddressSection 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:
  - toMaxHost
```
public abstract IPAddressSection 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:
  - toMaxHost
```
public abstract IPAddressSection 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:
  - 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.
    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 AddressSection
    
    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()
```
    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
    
    Overrides:
    
    includesZeroHost in class IPAddressDivisionGrouping
    
    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:
  - 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:
    
    whether the network portion of the address, the prefix, consists of a single value
  - matchesWithMask
```
public boolean matchesWithMask(IPAddressSection other,
                               IPAddressSection mask)
```
    Applies the mask to this address section and then compares values with the given address section
    
    Parameters:
    
    mask -
    
    other -
    
    Returns:
  - 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 AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Parameters:
    
    zeroed - whether the host bits become zero.
    
    Returns:
  - removePrefixLength
```
public abstract IPAddressSection removePrefixLength()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Removes the prefix length. The bits that were host bits become zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.removePrefixLength(boolean)
  - adjustPrefixBySegment
```
public IPAddressSection 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 AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    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:
  - adjustPrefixBySegment
```
public abstract IPAddressSection 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 AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    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, the bits moved outside the prefix become zero.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
public abstract IPAddressSection adjustPrefixLength(int adjustment,
                                                    boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    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 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.
    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 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: AddressSegmentSeries
    
    Sets the prefix length.
    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
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    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:
  - 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 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 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 first segment index 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:
  - prefixBlockIterator
```
public abstract java.util.Iterator<? extends IPAddressSection> 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 AddressSection
    
    Specified by:
    
    prefixBlockIterator in interface AddressSegmentSeries
    
    Specified by:
    
    prefixBlockIterator in interface IPAddressSegmentSeries
  - increment
```
public abstract IPAddressSection increment(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the series from the subnet that is the given increment upwards into the subnet range, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this. If the increment is 0, then this series is returned.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which is exceeds the size is added to the upper series of the range (the final iterator value) or is subtracted from the lower series of the range (the first iterator value) if negative.
    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 iterator. For instance, a increment of 1 is value 1 from the iterator, an increment of 2 is the second value from the iterator, and so on. A negative increment is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of -1 is the last value from the iterator, and increment of -2 is the second last value, and so on.
    Therefore, to get the series just above the highest series of the subnet, use an increment of size:count > 1 ? count + 1 : 1 where count is the subnet size. To get the series just below the lowest series of the subnet, use an increment of size:-(count > 1 ? count + 1 : 1) where count is the subnet size.
    
    Specified by:
    
    increment in interface AddressSection
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Specified by:
    
    increment 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.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

getDivision

containsPrefixBlock

contains

isFullRange

toZeroHost

toZeroHost

toMaxHost

toMaxHost

applyPrefixLength

toPrefixBlock

toPrefixBlock

assignPrefixForSingleBlock

assignMinPrefixForBlock

includesZeroHost

includesZeroHost

includesMaxHost

includesMaxHost

isSingleNetwork

matchesWithMask

removePrefixLength

removePrefixLength

adjustPrefixBySegment

adjustPrefixBySegment

adjustPrefixLength

adjustPrefixLength

setPrefixLength

setPrefixLength

getMinPrefixLengthForBlock

getPrefixLengthForSingleBlock

getLowerNonZeroHost

getLower

getUpper

reverseSegments

reverseBits

reverseBytes

reverseBytesPerSegment

getSection

getSection

getSegments

getSegments

getIterable

nonZeroHostIterator

iterator

prefixBlockIterator

increment

isEntireAddress

toString

getSegmentStrings

toBinaryString

toOctalString

toHexString

toNormalizedString

toNormalizedString

toStandardStringCollection