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, 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

static IPv6AddressSection LINK_LOCAL_PREFIX

int startIndex

Fields
Modifier and Type	Field and Description
`static IPv6AddressSection`	`LINK_LOCAL_PREFIX`
`int`	`startIndex`

Constructor Summary

Constructors
Constructor and Description
`IPv6AddressSection(byte[] bytes, 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(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`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`IPv6AddressSection`	`append(IPv6AddressSection other)`
`IPv6AddressSection`	`applyPrefixLength(int networkPrefixLength)` Applies the given network prefix bit length.
`IPv6AddressSection`	`bitwiseOr(IPv6AddressSection mask)` 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`	`createNonMixedSection()`
`boolean`	`equals(java.lang.Object o)`
`int`	`getBitsPerSegment()`
`int`	`getByteIndex(int networkPrefixLength)`
`int`	`getBytesPerSegment()`
`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(int networkPrefixLength)`
`IPAddress.IPVersion`	`getIPVersion()`
`java.lang.Iterable<IPv6AddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`IPv6AddressSection`	`getLower()` If this represents an address section with ranging values, returns an address section representing the lower values of the range If this represents an address section with a single value in each segment, returns this.
`IPv6AddressSection.IPv6v4MixedAddressSection`	`getMixedAddressSection()`
`IPv6AddressNetwork`	`getNetwork()`
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength)`
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength, boolean withPrefixLength)`
`IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions opts)` Get all representations of this address including this IPAddressSection.
`IPAddressStringDivisionSeries[]`	`getParts(IPv6AddressSection.IPv6StringBuilderOptions opts)`
`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)`
`int`	`getSegmentIndex(int networkPrefixLength)`
`IPv6AddressSegment[]`	`getSegments()`
`void`	`getSegments(java.util.Collection<? super IPv6AddressSegment> segs)`
`void`	`getSegments(int start, int end, java.util.Collection<? super IPv6AddressSegment> segs)`
`IPv6AddressSection`	`getUpper()` If this represents an address section with ranging values, returns an address section representing the upper values of the range If this represents an address section with a single value in each segment, returns this.
`IPAddressDivisionGrouping.RangeList`	`getZeroRangeSegments()`
`IPAddressDivisionGrouping.RangeList`	`getZeroSegments()`
`boolean`	`hasUppercaseVariations(int base, boolean lowerOnly)` Returns whether this subnet or address has alphabetic digits when printed.
`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()` An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values.
`IPv6AddressSection`	`mask(IPv6AddressSection mask)`
`IPv6AddressSection`	`maskNetwork(IPv6AddressSection mask, int networkPrefixLength)` Applies the given mask to the network section of the address as indicated by the given prefix length.
`IPv6AddressSection`	`prepend(IPv6AddressSection other)`
`IPv6AddressSection`	`removePrefixLength()` Removes the prefix.
`IPv6AddressSection`	`removePrefixLength(boolean zeroed)`
`IPv6AddressSection`	`replace(IPv6AddressSection other, int index)`
`IPv6AddressSection`	`reverseBits(boolean perByte)` Returns a new segment series with 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()`
`IPv6AddressSection`	`setPrefixLength(int networkPrefixLength)` Sets the prefix length.
`IPv6AddressSection`	`setPrefixLength(int networkPrefixLength, boolean withZeros)`
`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.
`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)`
`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.
`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 IPAddress.SEGMENT_SQL_WILDCARD instead of IPAddress.SEGMENT_WILDCARD -it uses IPAddress.SEGMENT_SQL_SINGLE_WILDCARD
`IPAddressPartStringCollection`	`toStandardStringCollection()` Returns at most a couple dozen string representations: -mixed (1:2:3:4:5:6:1.2.3.4) -upper and lower case -full compressions or no compression (a:0:0:c:d:0:e:f or a::c:d:0:e:f or a:0:b:c:d::e:f) -full leading zeros (000a:0000:000b:000c:000d:0000:000e:000f) -combinations thereof
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions options)`
`IPAddressPartStringCollection`	`toStringCollection(IPv6AddressSection.IPv6StringBuilderOptions opts)`
`java.lang.String`	`toSubnetString()` Produces a consistent subnet string.

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

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

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.format.AddressDivisionSeries
getDivision, getPrefixLength, isMore, isMultipleByPrefix, isPrefixed, isRangeEquivalentToPrefix

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

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

- Field Detail
  - LINK_LOCAL_PREFIX
```
public static final IPv6AddressSection LINK_LOCAL_PREFIX
```
  - startIndex
```
public final int startIndex
```
- 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)
```
    Constructs a single segment section with the segment at the given index in the address.
    
    Parameters:
    
    segment -
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments)
```
    Use this constructor for any address section that includes the leading segment of an IPv6 address
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments,
                          java.lang.Integer networkPrefixLength)
```
    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 -
  - IPv6AddressSection
```
public IPv6AddressSection(IPv6AddressSegment[] segments,
                          int startIndex,
                          java.lang.Integer networkPrefixLength)
```
    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 -
  - IPv6AddressSection
```
public IPv6AddressSection(byte[] bytes,
                          java.lang.Integer prefix)
```
  - 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.
    
    Parameters:
    
    eui -
    
    Throws:
    
    AddressTypeException - 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.
    
    Parameters:
    
    eui -
    
    Throws:
    
    AddressTypeException - 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(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index
    
    Specified by:
    
    getSection in interface AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in 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 AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in class IPAddressSection
    
    Returns:
  - getSegments
```
public IPv6AddressSegment[] getSegments()
```
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Specified by:
    
    getSegments in class IPAddressSection
    
    Returns:
    
    an array containing the segments
  - getLower
```
public IPv6AddressSection getLower()
```
    Description copied from class: IPAddressSection
    
    If this represents an address section with ranging values, returns an address section representing the lower values of the range If this represents an address section with a single value in each segment, returns this.
    
    Specified by:
    
    getLower in interface AddressComponent
    
    Specified by:
    
    getLower in interface AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Specified by:
    
    getLower in class IPAddressSection
    
    Returns:
  - getUpper
```
public IPv6AddressSection getUpper()
```
    Description copied from class: IPAddressSection
    
    If this represents an address section with ranging values, returns an address section representing the upper values of the range If this represents an address section with a single value in each segment, returns this.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Specified by:
    
    getUpper in class IPAddressSection
    
    Returns:
  - reverseBits
```
public IPv6AddressSection reverseBits(boolean perByte)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bits reversed.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSection
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    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 component 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 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 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 AddressTypeException.
    
    Specified by:
    
    reverseSegments in interface AddressSection
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    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 class IPAddressSection
    
    Returns:
  - iterator
```
public java.util.Iterator<IPv6AddressSection> iterator()
```
    Description copied from interface: AddressComponent
    
    An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values. Call AddressItem.isMultiple() to determine if this instance represents multiple. This method iterates through the individual elements.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface java.lang.Iterable<IPv6AddressSection>
    
    Specified by:
    
    iterator in class IPAddressSection
    
    Returns:
  - segmentsIterator
```
public java.util.Iterator<IPv6AddressSegment[]> segmentsIterator()
```
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsIterator in class IPAddressSection
  - getSegment
```
public IPv6AddressSegment getSegment(int index)
```
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Overrides:
    
    getSegment in class IPAddressSection
  - 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
    
    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()
```
  - getBitsPerSegment
```
public int getBitsPerSegment()
```
    Specified by:
    
    getBitsPerSegment in interface AddressSegmentSeries
  - getBytesPerSegment
```
public int getBytesPerSegment()
```
    Specified by:
    
    getBytesPerSegment in interface AddressSegmentSeries
  - 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()
```
    Specified by:
    
    getIPVersion in class IPAddressSection
  - replace
```
public IPv6AddressSection replace(IPv6AddressSection other,
                                  int index)
```
  - prepend
```
public IPv6AddressSection prepend(IPv6AddressSection other)
```
  - append
```
public IPv6AddressSection append(IPv6AddressSection other)
```
  - 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
    
    Returns:
    
    whether this section contains the given address section
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class IPAddressDivisionGrouping
  - subtract
```
public 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). Computes the subnet difference, the set of addresses in this address section but not in the provided section. 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:
    
    AddressTypeException - if the two sections are not comparable
  - getByteIndex
```
public int getByteIndex(int networkPrefixLength)
```
    Specified by:
    
    getByteIndex in class IPAddressSection
  - getSegmentIndex
```
public int getSegmentIndex(int networkPrefixLength)
```
    Specified by:
    
    getSegmentIndex in class IPAddressSection
  - getNetwork
```
public IPv6AddressNetwork getNetwork()
```
    Specified by:
    
    getNetwork in class IPAddressSection
  - adjustPrefixBySegment
```
public IPv6AddressSection adjustPrefixBySegment(boolean nextSegment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary. When prefix length is increased, the bits moved within the prefix are zero.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Overrides:
    
    adjustPrefixBySegment in class IPAddressSection
    
    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.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in class IPAddressSection
    
    Returns:
  - applyPrefixLength
```
public IPv6AddressSection applyPrefixLength(int networkPrefixLength)
```
    Description copied from class: IPAddressSection
    
    Applies the given network prefix bit length.
    
    Specified by:
    
    applyPrefixLength in interface AddressSection
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in class IPAddressSection
  - setPrefixLength
```
public IPv6AddressSection setPrefixLength(int networkPrefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length. When the series already had a prefix, and the prefix length is increased, the bits moved within the prefix are zero. When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSection
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class IPAddressSection
    
    Returns:
  - setPrefixLength
```
public IPv6AddressSection setPrefixLength(int networkPrefixLength,
                                          boolean withZeros)
```
    Specified by:
    
    setPrefixLength in class IPAddressSection
  - mask
```
public IPv6AddressSection mask(IPv6AddressSection mask)
                        throws AddressTypeException
```
    Throws:
    
    AddressTypeException
  - removePrefixLength
```
public IPv6AddressSection removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix. When the series already had a prefix, the bits previously not within the prefix are zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class IPAddressSection
    
    Returns:
  - removePrefixLength
```
public IPv6AddressSection removePrefixLength(boolean zeroed)
```
    Specified by:
    
    removePrefixLength in class IPAddressSection
  - maskNetwork
```
public IPv6AddressSection maskNetwork(IPv6AddressSection mask,
                                      int networkPrefixLength)
                               throws AddressTypeException
```
    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(IPv6AddressSection, int)
    
    Parameters:
    
    mask -
    
    networkPrefixLength -
    
    Returns:
    
    Throws:
    
    AddressTypeException
  - bitwiseOr
```
public IPv6AddressSection bitwiseOr(IPv6AddressSection mask)
                             throws AddressTypeException
```
    Does the bitwise disjunction with this address. Useful when subnetting. Any existing prefix is dropped.
    
    Parameters:
    
    mask -
    
    Returns:
    
    Throws:
    
    AddressTypeException
  - bitwiseOrNetwork
```
public IPv6AddressSection bitwiseOrNetwork(IPv6AddressSection mask,
                                           int networkPrefixLength)
                                    throws AddressTypeException
```
    Does the bitwise disjunction with this address. Useful when subnetting. 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:
    
    AddressTypeException
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength)
```
    Specified by:
    
    getNetworkSection in class IPAddressSection
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength,
                                            boolean withPrefixLength)
```
    Specified by:
    
    getNetworkSection in class IPAddressSection
  - getHostSection
```
public IPv6AddressSection getHostSection(int networkPrefixLength)
```
    Specified by:
    
    getHostSection in class IPAddressSection
  - toCompressedString
```
public java.lang.String toCompressedString()
```
    This produces the shortest valid string for the address.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Specified by:
    
    toCompressedString in class IPAddressSection
    
    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 class IPAddressSection
  - toCompressedWildcardString
```
public java.lang.String toCompressedWildcardString()
```
    Description copied from class: IPAddressSection
    
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
    
    Specified by:
    
    toCompressedWildcardString in class IPAddressSection
  - toPrefixLengthString
```
public java.lang.String toPrefixLengthString()
```
    Description copied from class: IPAddressSection
    
    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 class IPAddressSection
    
    Returns:
  - toSubnetString
```
public java.lang.String toSubnetString()
```
    Description copied from class: IPAddressSection
    
    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 class IPAddressSection
  - toCanonicalWildcardString
```
public java.lang.String toCanonicalWildcardString()
```
    Description copied from class: IPAddressSection
    
    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 class IPAddressSection
  - toNormalizedWildcardString
```
public java.lang.String toNormalizedWildcardString()
```
    Description copied from class: IPAddressSection
    
    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 class IPAddressSection
  - toSQLWildcardString
```
public java.lang.String toSQLWildcardString()
```
    Description copied from class: IPAddressSection
    
    This is the same as the string from toNormalizedWildcardString except that: -it uses IPAddress.SEGMENT_SQL_WILDCARD instead of IPAddress.SEGMENT_WILDCARD -it uses IPAddress.SEGMENT_SQL_SINGLE_WILDCARD
    
    Specified by:
    
    toSQLWildcardString in class IPAddressSection
  - 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 class: IPAddressSection
    
    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 class IPAddressSection
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions options)
```
    Overrides:
    
    toNormalizedString in class IPAddressSection
  - 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 class IPAddressSection
  - 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 has 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.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressItem

LINK_LOCAL_PREFIX

startIndex

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

IPv6AddressSection

getSection

getSection

getSegments

getLower

getUpper

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

getIterable

iterator

segmentsIterator

getSegment

getSegments

getSegments

isEUI64

isEUI64

toEUI

getEmbeddedIPv4AddressSection

getEmbeddedIPv4AddressSection

createNonMixedSection

getMixedAddressSection

getBitsPerSegment

getBytesPerSegment

hasUppercaseVariations

isIPv6

getIPVersion

replace

prepend

append

contains

equals

subtract

getByteIndex

getSegmentIndex

getNetwork

adjustPrefixBySegment

adjustPrefixLength

applyPrefixLength

setPrefixLength

setPrefixLength

mask

removePrefixLength

removePrefixLength

maskNetwork

bitwiseOr

bitwiseOrNetwork

getNetworkSection

getNetworkSection

getHostSection

toCompressedString

toCanonicalString

toMixedString

toFullString

toCompressedWildcardString

toPrefixLengthString

toSubnetString

toCanonicalWildcardString

toNormalizedWildcardString