IPv6AddressSection

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

All Implemented Interfaces:

AddressComponent, AddressSection, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressStringDivisionSeries, IPAddressStringDivisionSeries, IPAddressSegmentSeries, java.io.Serializable, java.lang.Comparable<AddressDivisionGrouping>, java.lang.Iterable<IPv6AddressSection>
```
public class IPv6AddressSection
extends IPAddressSection
implements java.lang.Iterable<IPv6AddressSection>
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`IPv6AddressSection.CompressOptions`
`static class`	`IPv6AddressSection.IPv6StringBuilderOptions`
`static class`	`IPv6AddressSection.IPv6StringOptions` Provides a clear way to create a specific type of string.
`static class`	`IPv6AddressSection.IPv6v4MixedAddressSection`

Nested classes/interfaces inherited from class inet.ipaddr.IPAddressSection
IPAddressSection.IPStringBuilderOptions, IPAddressSection.IPStringOptions, IPAddressSection.SegFunction<R,S>, 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

Field Summary

Fields
Modifier and Type Field and Description

int addressSegmentIndex

Fields
Modifier and Type	Field and Description
`int`	`addressSegmentIndex`

Constructor Summary

Constructors
Constructor and Description
`IPv6AddressSection(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, int segmentCount)`
`IPv6AddressSection(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, int segmentCount, java.lang.Integer networkPrefixLength)`
`IPv6AddressSection(Address.SegmentValueProvider valueProvider, int segmentCount)`
`IPv6AddressSection(Address.SegmentValueProvider valueProvider, int segmentCount, java.lang.Integer networkPrefixLength)`
`IPv6AddressSection(java.math.BigInteger val, int segmentCount)`
`IPv6AddressSection(java.math.BigInteger val, int segmentCount, java.lang.Integer networkPrefixLength)`
`IPv6AddressSection(byte[] bytes)`
`IPv6AddressSection(byte[] bytes, java.lang.Integer prefix)`
`IPv6AddressSection(byte[] bytes, int byteStartIndex, int byteEndIndex)`
`IPv6AddressSection(byte[] bytes, int byteStartIndex, int byteEndIndex, java.lang.Integer prefix)`
`IPv6AddressSection(IPv6AddressSegment segment)` Constructs a single segment section, the segment being the leading segment.
`IPv6AddressSection(IPv6AddressSegment[] segments)` Use this constructor for any address section that includes the leading segment of an IPv6 address
`IPv6AddressSection(IPv6AddressSegment[] segments, java.lang.Integer networkPrefixLength)` Use this constructor for any address section that includes the leading segment of an IPv6 address
`IPv6AddressSection(IPv6AddressSegment[] segments, int startIndex, java.lang.Integer networkPrefixLength)`
`IPv6AddressSection(IPv6AddressSegment segment, int startIndex)` Constructs a single segment section with the segment at the given index in the address.
`IPv6AddressSection(long highBytes, long lowBytes, int segmentCount)`
`IPv6AddressSection(long highBytes, long lowBytes, int segmentCount, java.lang.Integer networkPrefixLength)`
`IPv6AddressSection(MACAddress eui)` Constructs the corresponding IPv6 address section from a modified EUI-64 (Extended Unique Identifier) address.
`IPv6AddressSection(MACAddressSection eui)` Constructs the corresponding IPv6 address section from a modified EUI-64 (Extended Unique Identifier) address section.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IPv6AddressSection`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`IPv6AddressSection`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`IPv6AddressSection`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`IPv6AddressSection`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`IPv6AddressSection`	`append(IPv6AddressSection other)`
`IPv6AddressSection`	`appendToNetwork(IPv6AddressSection other)`
`IPv6AddressSection`	`applyPrefixLength(int networkPrefixLength)` Applies the given prefix length to create a new segment series.
`IPv6AddressSection`	`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.
`IPv6AddressSection`	`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.
`IPv6AddressSection`	`bitwiseOr(IPv6AddressSection mask)` Equivalent to `bitwiseOr(IPv6AddressSection, boolean)` with the second argument as false.
`IPv6AddressSection`	`bitwiseOr(IPv6AddressSection mask, boolean retainPrefix)` Does the bitwise disjunction with this address.
`IPv6AddressSection`	`bitwiseOrNetwork(IPv6AddressSection mask, int networkPrefixLength)` Does the bitwise disjunction with this address.
`boolean`	`contains(AddressSection other)` Determines if one section contains another.
`IPv6AddressSection`	`createMaxHost()`
`IPv6AddressSection`	`createNonMixedSection()`
`static IPv6AddressSection`	`createSection(IPv6AddressNetwork.IPv6AddressCreator creator, IPv6AddressSegment[] nonMixedSection, IPv4Address mixedSection)`
`boolean`	`equals(java.lang.Object o)`
`int`	`getBitCount()`
`int`	`getBitsPerSegment()` Returns the number of bits comprising each segment in this series.
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`int`	`getBytesPerSegment()` Returns the number of bytes comprising each segment in this series.
`IPv6AddressSegment`	`getDivision(int index)`
`IPv4AddressSection`	`getEmbeddedIPv4AddressSection()` Gets the IPv4 section corresponding to the lowest (least-significant) 4 bytes in the original address, which will correspond to between 0 and 4 bytes in this address.
`IPv4AddressSection`	`getEmbeddedIPv4AddressSection(int startIndex, int endIndex)` Produces an IPv4 address section from any sequence of bytes in this IPv6 address section
`IPv6AddressSection`	`getHostSection()` Returns the host section of the series.
`IPv6AddressSection`	`getHostSection(int networkPrefixLength)` Returns the host section of the address as indicated by the network prefix length provided.
`IPv4AddressNetwork`	`getIPv4Network()`
`IPv6Address`	`getIPv6Address(IPv4Address mixedSection)` Create an IPv6 mixed address using the given address for the embedded IPv4 segments
`IPAddress.IPVersion`	`getIPVersion()` Returns the version of this segment series
`java.lang.Iterable<IPv6AddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`IPv6AddressSection`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`IPv6AddressSection`	`getLowerNonZeroHost()` Similar to `IPAddressSegmentSeries.getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`MACAddressNetwork`	`getMACNetwork()`
`static java.math.BigInteger`	`getMaxValue(int segmentCount)`
`IPv6AddressSection.IPv6v4MixedAddressSection`	`getMixedAddressSection()`
`IPv6AddressNetwork`	`getNetwork()` Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`IPv6AddressSection`	`getNetworkSection()` Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength)` Returns the network section of the series.
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength, boolean withPrefixLength)` Returns the network section of the series.
`IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions opts)` Get all representations of this address including this IPAddressSection.
`IPAddressStringDivisionSeries[]`	`getParts(IPv6AddressSection.IPv6StringBuilderOptions opts)`
`java.math.BigInteger`	`getPrefixCount()` If this has a prefix length, the count of the range of values in the prefix.
`IPv6AddressSection`	`getSection()` Gets the subsection from the series that comprises all segments
`IPv6AddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`IPv6AddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`IPv6AddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`IPv6AddressSegment[]`	`getSegments()` Returns the segments of this series of segments as an array.
`void`	`getSegments(java.util.Collection<? super IPv6AddressSegment> segs)`
`void`	`getSegments(int start, int end, java.util.Collection<? super IPv6AddressSegment> segs)`
`IPv6AddressSection[]`	`getSpanningPrefixBlocks(IPv6AddressSection other)` Produces the list of prefix block subnets that span from this series to the given series.
`IPv6AddressSection`	`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.
`IPAddressDivisionGrouping.RangeList`	`getZeroRangeSegments()`
`IPAddressDivisionGrouping.RangeList`	`getZeroSegments()`
`boolean`	`hasUppercaseVariations(int base, boolean lowerOnly)` Returns whether this subnet or address has alphabetic digits when printed.
`IPv6AddressSection`	`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.
`IPv6AddressSection`	`insert(int index, IPv6AddressSection other)`
`IPv6AddressSection`	`intersect(IPv6AddressSection other)` Produces the subnet sections whose addresses are found in both this and the given argument.
`boolean`	`isEUI64()` Equivalent to isEUI64(false)
`boolean`	`isEUI64(boolean partial)` Whether this section is consistent with an EUI64 section, which means it came from an extended 8 byte address, and the corresponding segments in the middle match 0xff and 0xfe
`boolean`	`isIPv6()`
`boolean`	`isZero()`
`java.util.Iterator<IPv6AddressSection>`	`iterator()` Iterates through the individual segment series.
`IPv6AddressSection`	`mask(IPv6AddressSection mask)` Equivalent to `mask(IPv6AddressSection, boolean)` with the second argument as false.
`IPv6AddressSection`	`mask(IPv6AddressSection mask, boolean retainPrefix)` Does the bitwise conjuction with this address.
`IPv6AddressSection`	`maskNetwork(IPv6AddressSection mask, int networkPrefixLength)` Applies the given mask to the network section of the address as indicated by the given prefix length.
`boolean`	`matchesWithMask(IPAddressSection other, IPAddressSection mask)` Applies the mask to this address section and then compares values with the given address section
`IPv6AddressSection[]`	`mergeBlocks(IPv6AddressSection... sections)` Merges this with the list of sections to produce the smallest array of prefix blocks, going from smallest to largest
`java.util.Iterator<IPv6AddressSection>`	`nonZeroHostIterator()`
`java.util.Iterator<IPv6AddressSection>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`IPv6AddressSection`	`removePrefixLength()` Removes the prefix length.
`IPv6AddressSection`	`removePrefixLength(boolean zeroed)` Removes the prefix length.
`IPv6AddressSection`	`replace(int startIndex, int endIndex, IPv6AddressSection replacement, int replacementStartIndex, int replacementEndIndex)` Replaces segments starting from startIndex and ending before endIndex with the segments starting at replacementStartIndex and ending before replacementEndIndex from the replacement section
`IPv6AddressSection`	`replace(int startIndex, int endIndex, IPv6AddressSection replacement, int replacementStartIndex, int replacementEndIndex, boolean appendNetwork)`
`IPv6AddressSection`	`replace(int index, IPv6AddressSection replacement)` Replace the segments of this section starting at the given index with the given replacement segments
`IPv6AddressSection`	`reverseBits(boolean perByte)` Returns a new series which has the bits reversed.
`IPv6AddressSection`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`IPv6AddressSection`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`IPv6AddressSection`	`reverseSegments()` Returns a new segment series with the segments reversed.
`java.util.Iterator<IPv6AddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`java.util.Iterator<IPv6AddressSegment[]>`	`segmentsNonZeroHostIterator()`
`IPv6AddressSection`	`setPrefixLength(int networkPrefixLength)` Sets the prefix length.
`IPv6AddressSection`	`setPrefixLength(int networkPrefixLength, boolean withZeros)` Sets the prefix length.
`IPv6AddressSection[]`	`subtract(IPv6AddressSection other)` Subtract the give subnet from this subnet, returning an array of sections for the result (the subnets will not be contiguous so an array is required).
`IPAddressPartStringCollection`	`toAllStringCollection()` Use this method with care...
`java.lang.String`	`toBase85String()` The base 85 string is described by RFC 1924
`java.lang.String`	`toCanonicalString()` This produces a canonical string.
`java.lang.String`	`toCanonicalWildcardString()` This produces a string similar to the canonical string and avoids the CIDR prefix.
`java.lang.String`	`toCompressedString()` This produces the shortest valid string for the address.
`java.lang.String`	`toCompressedWildcardString()` This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
`IPAddressPartStringCollection`	`toDatabaseSearchStringCollection()` Returns a set of strings for search the standard string representations in a database -compress the largest compressible segments or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f) -upper/lowercase is not considered because many databases are case-insensitive
`MACAddressSection`	`toEUI(boolean extended)` Returns the corresponding mac section, or null if this address section does not correspond to a mac section.
`java.lang.String`	`toFullString()` This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments.
`IPv6AddressSection`	`toMaxHost()` Returns the segment series with a host of all ones.
`IPv6AddressSection`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`java.lang.String`	`toMixedString()` This produces the mixed IPv6/IPv4 string.
`java.lang.String`	`toNormalizedString()` The normalized string returned by this method is consistent with java.net.Inet6address.
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions options)` Creates a customized string from this series.
`static java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions options, java.lang.CharSequence zone, IPAddressStringDivisionSeries part)`
`java.lang.String`	`toNormalizedString(IPv6AddressSection.IPv6StringOptions options)`
`java.lang.String`	`toNormalizedString(IPv6AddressSection.IPv6StringOptions options, java.lang.CharSequence zone)`
`java.lang.String`	`toNormalizedWildcardString()` This produces a string similar to the normalized string and avoids the CIDR prefix.
`IPv6AddressSection`	`toPrefixBlock()` If this series has a prefix length, returns the subnet block for that prefix.
`IPv6AddressSection`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`java.lang.String`	`toPrefixLengthString()` Returns a string with a CIDR prefix length if this section has a network prefix length.
`java.lang.String`	`toReverseDNSLookupString()` Generates the reverse DNS lookup string For 8.255.4.4 it is 4.4.255.8.in-addr.arpa For 2001:db8::567:89ab it is b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa
`java.lang.String`	`toSQLWildcardString()` This is the same as the string from toNormalizedWildcardString except that it uses `Address.SEGMENT_SQL_WILDCARD` instead of `Address.SEGMENT_WILDCARD` and also uses `Address.SEGMENT_SQL_SINGLE_WILDCARD`
`IPAddressPartStringCollection`	`toStandardStringCollection()` 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
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions options)`
`IPAddressPartStringCollection`	`toStringCollection(IPv6AddressSection.IPv6StringBuilderOptions opts)`
`java.lang.String`	`toSubnetString()` Produces a consistent subnet string.
`IPv6AddressSection`	`toZeroHost()` Returns the segment series with a host of zero.
`IPv6AddressSection`	`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, getNetworkPrefixLength, getPrefixLength, isMore, isPrefixBlock, isPrefixed, isSinglePrefixBlock

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

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface inet.ipaddr.IPAddressSegmentSeries
getNetworkPrefixLength

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

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

Methods inherited from interface inet.ipaddr.format.AddressItem
getBytes, getBytes, getCount, getUpperBytes, getUpperBytes, includesMax, includesZero, isMax, isMultiple

- Field Detail
  - addressSegmentIndex
```
public final int addressSegmentIndex
```
- Constructor Detail
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment segment)
```
    Constructs a single segment section, the segment being the leading segment.
    
    Parameters:
    
    segment -
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment segment,
                          int startIndex)
                   throws java.lang.IllegalArgumentException
```
    Constructs a single segment section with the segment at the given index in the address.
    
    Parameters:
    
    segment -
    
    Throws:
    
    java.lang.IllegalArgumentException
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments)
                   throws AddressValueException
```
    Use this constructor for any address section that includes the leading segment of an IPv6 address
    
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments,
                          java.lang.Integer networkPrefixLength)
                   throws AddressValueException
```
    Use this constructor for any address section that includes the leading segment of an IPv6 address
    
    Parameters:
    
    segments - an array containing the segments. Segments that are entirely part of the host section need not be provided, although the array must be the correct length.
    
    networkPrefixLength -
    
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments,
                          int startIndex,
                          java.lang.Integer networkPrefixLength)
                   throws java.lang.IllegalArgumentException,
                          AddressValueException
```
    Parameters:
    
    startIndex - the index of the first segment where this section would be located in a full address, 0 for network sections or full addresses
    
    segments - an array containing the segments. Segments that are entirely part of the host section need not be provided, although the array must be the correct length.
    
    networkPrefixLength -
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(Address.SegmentValueProvider valueProvider,
                          int segmentCount,
                          java.lang.Integer networkPrefixLength)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(Address.SegmentValueProvider lowerValueProvider,
                          Address.SegmentValueProvider upperValueProvider,
                          int segmentCount,
                          java.lang.Integer networkPrefixLength)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(Address.SegmentValueProvider valueProvider,
                          int segmentCount)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(Address.SegmentValueProvider lowerValueProvider,
                          Address.SegmentValueProvider upperValueProvider,
                          int segmentCount)
```
  - IPv6AddressSection
```
public IPv6AddressSection(byte[] bytes,
                          int byteStartIndex,
                          int byteEndIndex,
                          java.lang.Integer prefix)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(byte[] bytes,
                          int byteStartIndex,
                          int byteEndIndex)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(byte[] bytes,
                          java.lang.Integer prefix)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(byte[] bytes)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(java.math.BigInteger val,
                          int segmentCount,
                          java.lang.Integer networkPrefixLength)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(java.math.BigInteger val,
                          int segmentCount)
                   throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6AddressSection
```
public IPv6AddressSection(long highBytes,
                          long lowBytes,
                          int segmentCount,
                          java.lang.Integer networkPrefixLength)
                   throws PrefixLenException
```
    Throws:
    
    PrefixLenException
  - IPv6AddressSection
```
public IPv6AddressSection(long highBytes,
                          long lowBytes,
                          int segmentCount)
```
  - IPv6AddressSection
```
public IPv6AddressSection(MACAddress eui)
```
    Constructs the corresponding IPv6 address section from a modified EUI-64 (Extended Unique Identifier) address.
    If the supplied address is an 8 byte EUI-64, then it must match the required EUI-64 format of xx-xx-ff-fe-xx-xx with the ff-fe section in the middle. If the supplied address is a 6 byte MAC-48 or EUI-48, then the ff-fe pattern will be inserted.
    The constructor will toggle the MAC U/L (universal/local) bit as required with EUI-64.
    Any prefix length in the MAC address is ignored.
    
    Parameters:
    
    eui -
    
    Throws:
    
    IncompatibleAddressException - when the MAC address is an EUI-64 that cannot be converted to an IPv6 address (ff-fe section in middle)
  - IPv6AddressSection
```
public IPv6AddressSection(MACAddressSection eui)
```
    Constructs the corresponding IPv6 address section from a modified EUI-64 (Extended Unique Identifier) address section.
    If the supplied address section comes from an 8 byte EUI-64, then it must match the required EUI-64 format of xx-xx-ff-fe-xx-xx with the ff-fe section in the middle. If the supplied address section comes from a 6 byte MAC-48 or EUI-48, then the ff-fe pattern will be inserted.
    The constructor will toggle the MAC U/L (universal/local) bit as required with EUI-64.
    Any prefix length in the MAC address section is ignored.
    
    Parameters:
    
    eui -
    
    Throws:
    
    IncompatibleAddressException - when the MAC address section is an EUI-64 that cannot be converted to an IPv6 address (ff-fe section in middle)
- Method Detail
  - getSection
```
public IPv6AddressSection getSection()
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series that comprises all segments
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Returns:
  - getSection
```
public IPv6AddressSection 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
    
    Specified by:
    
    getSection in class IPAddressSection
    
    Returns:
  - getSection
```
public IPv6AddressSection 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
    
    Specified by:
    
    getSection in class IPAddressSection
    
    Returns:
  - getSegments
```
public IPv6AddressSegment[] getSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segments of this series of segments as an array. This must create a new array, so for efficiency use AddressSegmentSeries.getSegment(int) and AddressSegmentSeries.getSegmentCount() instead when feasible.
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Specified by:
    
    getSegments in interface IPAddressSegmentSeries
    
    Returns:
  - getLowerNonZeroHost
```
public IPv6AddressSection 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
    
    Specified by:
    
    getLowerNonZeroHost in class IPAddressSection
    
    Returns:
    
    the lowest IP address series whose host is non-zero, or null if no such address section exists.
  - getLower
```
public IPv6AddressSection 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
    
    Specified by:
    
    getLower in class IPAddressSection
    
    Returns:
  - getUpper
```
public IPv6AddressSection 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
    
    Specified by:
    
    getUpper in class IPAddressSection
    
    Returns:
  - reverseBits
```
public IPv6AddressSection 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
    
    Specified by:
    
    reverseBits in class IPAddressSection
    
    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 IPv6AddressSection 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
    
    Specified by:
    
    reverseBytes in class IPAddressSection
    
    Returns:
  - reverseBytesPerSegment
```
public IPv6AddressSection 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
    
    Specified by:
    
    reverseBytesPerSegment in class IPAddressSection
    
    Returns:
  - reverseSegments
```
public IPv6AddressSection 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
    
    Specified by:
    
    reverseSegments in class IPAddressSection
    
    Returns:
  - getIterable
```
public java.lang.Iterable<IPv6AddressSection> 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
    
    Specified by:
    
    getIterable in class IPAddressSection
    
    Returns:
  - nonZeroHostIterator
```
public java.util.Iterator<IPv6AddressSection> nonZeroHostIterator()
```
    Specified by:
    
    nonZeroHostIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    nonZeroHostIterator in class IPAddressSection
  - iterator
```
public java.util.Iterator<IPv6AddressSection> 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
    
    Specified by:
    
    iterator in interface java.lang.Iterable<IPv6AddressSection>
    
    Specified by:
    
    iterator in class IPAddressSection
    
    Returns:
  - prefixBlockIterator
```
public java.util.Iterator<IPv6AddressSection> 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
    
    Specified by:
    
    prefixBlockIterator in class IPAddressSection
  - segmentsNonZeroHostIterator
```
public java.util.Iterator<IPv6AddressSegment[]> segmentsNonZeroHostIterator()
```
    Specified by:
    
    segmentsNonZeroHostIterator in interface IPAddressSegmentSeries
  - segmentsIterator
```
public java.util.Iterator<IPv6AddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsIterator in interface IPAddressSegmentSeries
  - getMaxValue
```
public static java.math.BigInteger getMaxValue(int segmentCount)
```
  - increment
```
public IPv6AddressSection 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
    
    Specified by:
    
    increment in class IPAddressSection
    
    Returns:
  - getPrefixCount
```
public java.math.BigInteger getPrefixCount()
```
    Description copied from interface: AddressDivisionSeries
    
    If this has a prefix length, the count of the range of values in the prefix.
    If this has no prefix length, returns the same value as AddressItem.getCount()
    
    Specified by:
    
    getPrefixCount in interface AddressDivisionSeries
    
    Overrides:
    
    getPrefixCount in class AddressDivisionGrouping
    
    Returns:
  - getDivision
```
public IPv6AddressSegment 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 IPAddressSection
    
    Returns:
    
    the given division in this series. The first is at index 0.
  - getSegment
```
public IPv6AddressSegment 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
    
    Overrides:
    
    getSegment in class IPAddressSection
    
    Returns:
  - getSegments
```
public void getSegments(java.util.Collection<? super IPv6AddressSegment> segs)
```
  - getSegments
```
public void getSegments(int start,
                        int end,
                        java.util.Collection<? super IPv6AddressSegment> segs)
```
  - isEUI64
```
public boolean isEUI64()
```
    Equivalent to isEUI64(false)
    
    Returns:
  - isEUI64
```
public boolean isEUI64(boolean partial)
```
    Whether this section is consistent with an EUI64 section, which means it came from an extended 8 byte address, and the corresponding segments in the middle match 0xff and 0xfe
    
    Parameters:
    
    partial - whether missing segments are considered a match
    
    Returns:
  - toEUI
```
public MACAddressSection toEUI(boolean extended)
```
    Returns the corresponding mac section, or null if this address section does not correspond to a mac section. If this address section has a prefix length it is ignored.
    
    Parameters:
    
    extended -
    
    Returns:
  - getEmbeddedIPv4AddressSection
```
public IPv4AddressSection getEmbeddedIPv4AddressSection(int startIndex,
                                                        int endIndex)
```
    Produces an IPv4 address section from any sequence of bytes in this IPv6 address section
    
    Parameters:
    
    startIndex - the byte index in this section to start from
    
    endIndex - the byte index in this section to end at
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    See Also:
    
    getEmbeddedIPv4AddressSection(), getMixedAddressSection()
  - getEmbeddedIPv4AddressSection
```
public IPv4AddressSection getEmbeddedIPv4AddressSection()
```
    Gets the IPv4 section corresponding to the lowest (least-significant) 4 bytes in the original address, which will correspond to between 0 and 4 bytes in this address. Many IPv4 to IPv6 mapping schemes (but not all) use these 4 bytes for a mapped IPv4 address.
    
    Returns:
    
    the embedded IPv4 section or null
    
    See Also:
    
    getEmbeddedIPv4AddressSection(int, int), getMixedAddressSection()
  - createNonMixedSection
```
public IPv6AddressSection createNonMixedSection()
```
  - getMixedAddressSection
```
public IPv6AddressSection.IPv6v4MixedAddressSection getMixedAddressSection()
```
  - createSection
```
public static IPv6AddressSection createSection(IPv6AddressNetwork.IPv6AddressCreator creator,
                                               IPv6AddressSegment[] nonMixedSection,
                                               IPv4Address mixedSection)
                                        throws IncompatibleAddressException
```
    Throws:
    
    IncompatibleAddressException
  - getIPv6Address
```
public IPv6Address getIPv6Address(IPv4Address mixedSection)
```
    Create an IPv6 mixed address using the given address for the embedded IPv4 segments
    
    Parameters:
    
    mixedSection - the IPv4 address used to construct the terminating segments of the returned address
    
    Returns:
  - getBitsPerSegment
```
public int getBitsPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of bits comprising each segment in this series. Segments in the same series are equal length.
    
    Specified by:
    
    getBitsPerSegment in interface AddressSegmentSeries
    
    Returns:
  - getBytesPerSegment
```
public int getBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of bytes comprising each segment in this series. Segments in the same series are equal length.
    
    Specified by:
    
    getBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class IPAddressSection
    
    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
    
    Overrides:
    
    getByteCount in class IPAddressSection
    
    Returns:
  - hasUppercaseVariations
```
public boolean hasUppercaseVariations(int base,
                                      boolean lowerOnly)
```
    Returns whether this subnet or address has alphabetic digits when printed. Note that this method does not indicate whether any address contained within this subnet has alphabetic digits, only whether the subnet itself when printed has alphabetic digits.
    
    Returns:
    
    whether the section has alphabetic digits when printed.
  - isIPv6
```
public boolean isIPv6()
```
    Overrides:
    
    isIPv6 in class IPAddressSection
  - getIPVersion
```
public IPAddress.IPVersion getIPVersion()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the version of this segment series
    
    Specified by:
    
    getIPVersion in interface IPAddressSegmentSeries
    
    Returns:
  - append
```
public IPv6AddressSection append(IPv6AddressSection other)
```
  - appendToNetwork
```
public IPv6AddressSection appendToNetwork(IPv6AddressSection other)
```
  - insert
```
public IPv6AddressSection insert(int index,
                                 IPv6AddressSection other)
```
  - replace
```
public IPv6AddressSection replace(int index,
                                  IPv6AddressSection replacement)
```
    Replace the segments of this section starting at the given index with the given replacement segments
    
    Parameters:
    
    index -
    
    replacement -
    
    Returns:
  - replace
```
public IPv6AddressSection replace(int startIndex,
                                  int endIndex,
                                  IPv6AddressSection replacement,
                                  int replacementStartIndex,
                                  int replacementEndIndex)
```
    Replaces segments starting from startIndex and ending before endIndex with the segments starting at replacementStartIndex and ending before replacementEndIndex from the replacement section
    
    Parameters:
    
    startIndex -
    
    endIndex -
    
    replacement -
    
    replacementStartIndex -
    
    replacementEndIndex -
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    AddressValueException - if the resulting section would exceed the maximum segment count for this address type and version
  - replace
```
public IPv6AddressSection replace(int startIndex,
                                  int endIndex,
                                  IPv6AddressSection replacement,
                                  int replacementStartIndex,
                                  int replacementEndIndex,
                                  boolean appendNetwork)
```
  - 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
    
    Overrides:
    
    contains in class IPAddressSection
    
    Returns:
    
    whether this subnet contains the given address section
  - matchesWithMask
```
public boolean matchesWithMask(IPAddressSection other,
                               IPAddressSection mask)
```
    Description copied from class: IPAddressSection
    
    Applies the mask to this address section and then compares values with the given address section
    
    Overrides:
    
    matchesWithMask in class IPAddressSection
    
    Returns:
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class IPAddressDivisionGrouping
  - intersect
```
public IPv6AddressSection intersect(IPv6AddressSection other)
                             throws SizeMismatchException
```
    Produces the subnet sections whose addresses are found in both this and the given argument.
    This is also known as the conjunction of the two sets of address sections.
    
    Parameters:
    
    other -
    
    Returns:
    
    the section containing the sections found in both this and the given subnet sections
    
    Throws:
    
    SizeMismatchException
  - subtract
```
public IPv6AddressSection[] subtract(IPv6AddressSection other)
                              throws SizeMismatchException
```
    Subtract the give subnet from this subnet, returning an array of sections for the result (the subnets will not be contiguous so an array is required).
    Computes the subnet difference, the set of addresses in this address section but not in the provided section. This is also known as the relative complement of the given argument in this subnet.
    Keep in mind this is set subtraction, not subtraction of segment values. We have a subnet of addresses and we are removing some of those addresses.
    
    Parameters:
    
    other -
    
    Returns:
    
    the difference
    
    Throws:
    
    SizeMismatchException - if the two sections have different sizes
  - getNetwork
```
public IPv6AddressNetwork getNetwork()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressSegmentSeries
    
    Specified by:
    
    getNetwork in interface IPAddressStringDivisionSeries
    
    Specified by:
    
    getNetwork in interface IPAddressSegmentSeries
    
    Overrides:
    
    getNetwork in class IPAddressDivisionGrouping
  - getIPv4Network
```
public IPv4AddressNetwork getIPv4Network()
```
  - getMACNetwork
```
public MACAddressNetwork getMACNetwork()
```
  - adjustPrefixBySegment
```
public IPv6AddressSection 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
    
    Specified by:
    
    adjustPrefixBySegment in class IPAddressSection
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    Returns:
  - adjustPrefixBySegment
```
public IPv6AddressSection 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
    
    Overrides:
    
    adjustPrefixBySegment in class IPAddressSection
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - adjustPrefixLength
```
public IPv6AddressSection 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
    
    Specified by:
    
    adjustPrefixLength in class IPAddressSection
    
    Returns:
  - adjustPrefixLength
```
public IPv6AddressSection 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
    
    Specified by:
    
    adjustPrefixLength in class IPAddressSection
    
    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:
  - applyPrefixLength
```
public IPv6AddressSection 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
    
    Specified by:
    
    applyPrefixLength in class IPAddressSection
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - setPrefixLength
```
public IPv6AddressSection setPrefixLength(int networkPrefixLength)
                                   throws PrefixLenException
```
    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
    
    Specified by:
    
    setPrefixLength in class IPAddressSection
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.applyPrefixLength(int)
  - setPrefixLength
```
public IPv6AddressSection setPrefixLength(int networkPrefixLength,
                                          boolean withZeros)
                                   throws PrefixLenException
```
    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
    
    Specified by:
    
    setPrefixLength in class IPAddressSection
    
    withZeros - 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:
    
    Throws:
    
    PrefixLenException
  - removePrefixLength
```
public IPv6AddressSection 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
    
    Specified by:
    
    removePrefixLength in class IPAddressSection
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.removePrefixLength(boolean)
  - removePrefixLength
```
public IPv6AddressSection 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
    
    Specified by:
    
    removePrefixLength in class IPAddressSection
    
    Parameters:
    
    zeroed - whether the host bits become zero.
    
    Returns:
  - bitwiseOrNetwork
```
public IPv6AddressSection bitwiseOrNetwork(IPv6AddressSection mask,
                                           int networkPrefixLength)
                                    throws IncompatibleAddressException,
                                           PrefixLenException,
                                           SizeMismatchException
```
    Does the bitwise disjunction with this address. Useful when subnetting. Similar to maskNetwork(IPv6AddressSection, int) which does the bitwise conjunction.
    Any existing prefix length is dropped for the new prefix length and the mask is applied up to the end the new prefix length.
    
    Parameters:
    
    mask -
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
    
    PrefixLenException
    
    SizeMismatchException
  - bitwiseOr
```
public IPv6AddressSection bitwiseOr(IPv6AddressSection mask)
                             throws IncompatibleAddressException
```
    Equivalent to bitwiseOr(IPv6AddressSection, boolean) with the second argument as false.
    
    Throws:
    
    IncompatibleAddressException
  - bitwiseOr
```
public IPv6AddressSection bitwiseOr(IPv6AddressSection mask,
                                    boolean retainPrefix)
                             throws IncompatibleAddressException,
                                    SizeMismatchException
```
    Does the bitwise disjunction with this address. Useful when subnetting. Similar to mask(IPv6AddressSection) which does the bitwise conjunction.
    
    Parameters:
    
    mask -
    
    retainPrefix - whether to drop the prefix
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
    
    SizeMismatchException
  - toZeroHost
```
public IPv6AddressSection toZeroHost()
                              throws IncompatibleAddressException
```
    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
    
    Specified by:
    
    toZeroHost in class IPAddressSection
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
  - toZeroHost
```
public IPv6AddressSection 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
    
    Specified by:
    
    toZeroHost in class IPAddressSection
    
    Returns:
  - toMaxHost
```
public IPv6AddressSection toMaxHost()
                             throws IncompatibleAddressException
```
    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
    
    Specified by:
    
    toMaxHost in class IPAddressSection
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
  - createMaxHost
```
public IPv6AddressSection createMaxHost()
```
  - toMaxHost
```
public IPv6AddressSection 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
    
    Specified by:
    
    toMaxHost in class IPAddressSection
    
    Returns:
  - mask
```
public IPv6AddressSection mask(IPv6AddressSection mask,
                               boolean retainPrefix)
                        throws IncompatibleAddressException,
                               SizeMismatchException
```
    Does the bitwise conjuction with this address. Useful when subnetting.
    
    Parameters:
    
    mask -
    
    retainPrefix - whether to drop the prefix
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
    
    SizeMismatchException
  - mask
```
public IPv6AddressSection mask(IPv6AddressSection mask)
                        throws IncompatibleAddressException
```
    Equivalent to mask(IPv6AddressSection, boolean) with the second argument as false.
    
    Throws:
    
    IncompatibleAddressException
  - maskNetwork
```
public IPv6AddressSection maskNetwork(IPv6AddressSection mask,
                                      int networkPrefixLength)
                               throws IncompatibleAddressException,
                                      PrefixLenException,
                                      SizeMismatchException
```
    Applies the given mask to the network section of the address as indicated by the given prefix length. Useful for subnetting. Once you have zeroed a section of the network you can insert bits using bitwiseOr(IPv6AddressSection) or replace(int, IPv6AddressSection)
    
    Parameters:
    
    mask -
    
    networkPrefixLength -
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException
    
    PrefixLenException
    
    SizeMismatchException
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    Returns:
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength)
                                     throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. It will have networkPrefixLength as its associated prefix length, unless this address already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength,
                                            boolean withPrefixLength)
                                     throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. If withPrefixLength is true, it will have networkPrefixLength as its associated prefix length, unless this series already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    withPrefixLength - whether the resulting section will have networkPrefixLength as the associated prefix length or not
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getHostSection
```
public IPv6AddressSection getHostSection()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the host section of the series. The returned section will have only as many segments as needed as determined by the existing CIDR network prefix length. If this series has no CIDR prefix length, the returned host section will be the full section associated with a prefix length of 0.
    
    Specified by:
    
    getHostSection in interface IPAddressSegmentSeries
    
    Returns:
  - getHostSection
```
public IPv6AddressSection getHostSection(int networkPrefixLength)
                                  throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the host section of the address as indicated by the network prefix length provided. The returned section will have only as many segments as needed to hold the host as indicated by the provided network prefix length.
    
    Specified by:
    
    getHostSection in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - toPrefixBlock
```
public IPv6AddressSection 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
    
    Specified by:
    
    toPrefixBlock in class IPAddressSection
    
    Returns:
    
    the subnet block for the prefix length
  - assignPrefixForSingleBlock
```
public IPv6AddressSection assignPrefixForSingleBlock()
```
    Description copied from class: IPAddressSection
    
    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
    
    Overrides:
    
    assignPrefixForSingleBlock in class IPAddressSection
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignMinPrefixForBlock()
  - assignMinPrefixForBlock
```
public IPv6AddressSection assignMinPrefixForBlock()
```
    Description copied from class: IPAddressSection
    
    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
    
    Overrides:
    
    assignMinPrefixForBlock in class IPAddressSection
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignPrefixForSingleBlock()
  - toPrefixBlock
```
public IPv6AddressSection toPrefixBlock(int networkPrefixLength)
                                 throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series of the same length that spans all hosts. The network prefix length will be the one provided, and the network values will match the same of this series.
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in class IPAddressSection
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getSpanningPrefixBlocks
```
public IPv6AddressSection[] getSpanningPrefixBlocks(IPv6AddressSection other)
                                             throws AddressPositionException
```
    Produces the list of prefix block subnets that span from this series to the given series.
    
    Parameters:
    
    other -
    
    Returns:
    
    Throws:
    
    AddressPositionException
  - mergeBlocks
```
public IPv6AddressSection[] mergeBlocks(IPv6AddressSection... sections)
                                 throws SizeMismatchException,
                                        AddressPositionException
```
    Merges this with the list of sections to produce the smallest array of prefix blocks, going from smallest to largest
    
    Parameters:
    
    sections - the sections to merge with this
    
    Returns:
    
    Throws:
    
    SizeMismatchException
    
    AddressPositionException
  - toCompressedString
```
public java.lang.String toCompressedString()
```
    This produces the shortest valid string for the address.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Returns:
  - toCanonicalString
```
public java.lang.String toCanonicalString()
```
    This produces a canonical string. RFC 5952 describes canonical representations. http://en.wikipedia.org/wiki/IPv6_address#Recommended_representation_as_text http://tools.ietf.org/html/rfc5952
    
    Specified by:
    
    toCanonicalString in interface AddressSegmentSeries
    
    Returns:
  - toMixedString
```
public java.lang.String toMixedString()
```
    This produces the mixed IPv6/IPv4 string. It is the shortest such string (ie fully compressed).
  - toFullString
```
public java.lang.String toFullString()
```
    This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments.
    
    Specified by:
    
    toFullString in interface IPAddressSegmentSeries
  - toCompressedWildcardString
```
public java.lang.String toCompressedWildcardString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
    
    Specified by:
    
    toCompressedWildcardString in interface IPAddressSegmentSeries
  - toPrefixLengthString
```
public java.lang.String toPrefixLengthString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns a string with a CIDR prefix length if this section has a network prefix length. For IPv6, the host section will be compressed with ::, for IPv4 the host section will be zeros.
    
    Specified by:
    
    toPrefixLengthString in interface IPAddressSegmentSeries
    
    Returns:
  - toSubnetString
```
public java.lang.String toSubnetString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Produces a consistent subnet string. In the case of IPv4, this means that wildcards are used instead of a network prefix. In the case of IPv6, a prefix will be used and the host section will be compressed with ::.
    
    Specified by:
    
    toSubnetString in interface IPAddressSegmentSeries
  - toCanonicalWildcardString
```
public java.lang.String toCanonicalWildcardString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    This produces a string similar to the canonical string and avoids the CIDR prefix. Addresses with a network prefix length will be shown with wildcards and ranges instead of using the CIDR prefix length notation. IPv6 addresses will be compressed according to the canonical representation.
    
    Specified by:
    
    toCanonicalWildcardString in interface IPAddressSegmentSeries
  - toNormalizedWildcardString
```
public java.lang.String toNormalizedWildcardString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    This produces a string similar to the normalized string and avoids the CIDR prefix. CIDR addresses will be shown with wildcards and ranges instead of using the CIDR prefix notation.
    
    Specified by:
    
    toNormalizedWildcardString in interface IPAddressSegmentSeries
  - toSQLWildcardString
```
public java.lang.String toSQLWildcardString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    This is the same as the string from toNormalizedWildcardString except that it uses Address.SEGMENT_SQL_WILDCARD instead of Address.SEGMENT_WILDCARD and also uses Address.SEGMENT_SQL_SINGLE_WILDCARD
    
    Specified by:
    
    toSQLWildcardString in interface IPAddressSegmentSeries
  - toNormalizedString
```
public java.lang.String toNormalizedString()
```
    The normalized string returned by this method is consistent with java.net.Inet6address. IPs are not compressed nor mixed in this representation.
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toBase85String
```
public java.lang.String toBase85String()
```
    The base 85 string is described by RFC 1924
    
    Returns:
  - toReverseDNSLookupString
```
public java.lang.String toReverseDNSLookupString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Generates the reverse DNS lookup string For 8.255.4.4 it is 4.4.255.8.in-addr.arpa For 2001:db8::567:89ab it is b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa
    
    Specified by:
    
    toReverseDNSLookupString in interface IPAddressSegmentSeries
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions options)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Creates a customized string from this series.
    
    Specified by:
    
    toNormalizedString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toNormalizedString in class IPAddressSection
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPv6AddressSection.IPv6StringOptions options)
```
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPv6AddressSection.IPv6StringOptions options,
                                           java.lang.CharSequence zone)
```
  - toNormalizedString
```
public static java.lang.String toNormalizedString(IPAddressSection.IPStringOptions options,
                                                  java.lang.CharSequence zone,
                                                  IPAddressStringDivisionSeries part)
```
  - toStandardStringCollection
```
public IPAddressPartStringCollection toStandardStringCollection()
```
    Description copied from class: IPAddressSection
    
    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
    
    Overrides:
    
    toStandardStringCollection in class IPAddressSection
    
    Returns:
  - toAllStringCollection
```
public IPAddressPartStringCollection toAllStringCollection()
```
    Description copied from class: IPAddressSection
    
    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)
    
    Overrides:
    
    toAllStringCollection in class IPAddressSection
    
    Returns:
  - toDatabaseSearchStringCollection
```
public IPAddressPartStringCollection toDatabaseSearchStringCollection()
```
    Description copied from class: IPAddressSection
    
    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
    
    Overrides:
    
    toDatabaseSearchStringCollection in class IPAddressSection
    
    Returns:
  - toStringCollection
```
public IPAddressPartStringCollection toStringCollection(IPAddressSection.IPStringBuilderOptions options)
```
    Specified by:
    
    toStringCollection in interface IPAddressSegmentSeries
  - toStringCollection
```
public IPAddressPartStringCollection toStringCollection(IPv6AddressSection.IPv6StringBuilderOptions opts)
```
  - getParts
```
public IPAddressStringDivisionSeries[] getParts(IPAddressSection.IPStringBuilderOptions opts)
```
    Description copied from class: IPAddressSection
    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
    Overrides:
    
    getParts in class IPAddressSection
    
    Returns:
  - getParts
```
public IPAddressStringDivisionSeries[] getParts(IPv6AddressSection.IPv6StringBuilderOptions opts)
```
  - getZeroSegments
```
public IPAddressDivisionGrouping.RangeList getZeroSegments()
```
    Overrides:
    
    getZeroSegments in class IPAddressDivisionGrouping
    
    Returns:
    
    the segments which are zero
  - getZeroRangeSegments
```
public IPAddressDivisionGrouping.RangeList getZeroRangeSegments()
```
    Overrides:
    
    getZeroRangeSegments in class IPAddressDivisionGrouping
    
    Returns:
    
    the segments which are zero or whose prefix-based range includes 0
  - isZero
```
public boolean isZero()
```
    Specified by:
    
    isZero in interface AddressItem
    
    Overrides:
    
    isZero in class AddressDivisionGrouping
    
    Returns:
    
    whether this item matches the value of zero

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

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

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 java.lang.Iterable

Methods inherited from interface inet.ipaddr.IPAddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressItem

addressSegmentIndex

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

getSection

getSection

getSection

getSegments

getLowerNonZeroHost

getLower

getUpper

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

getIterable

nonZeroHostIterator

iterator

prefixBlockIterator

segmentsNonZeroHostIterator

segmentsIterator

getMaxValue

increment

getPrefixCount

getDivision

getSegment

getSegments

getSegments

isEUI64

isEUI64

toEUI

getEmbeddedIPv4AddressSection

getEmbeddedIPv4AddressSection

createNonMixedSection

getMixedAddressSection

createSection

getIPv6Address

getBitsPerSegment

getBytesPerSegment

getBitCount

getByteCount

hasUppercaseVariations

isIPv6

getIPVersion

append

appendToNetwork

insert

replace

replace

replace

contains

matchesWithMask