MACAddressSection (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.format.AddressDivisionGroupingBase
- - inet.ipaddr.format.standard.AddressDivisionGrouping
  - - inet.ipaddr.mac.MACAddressSection

All Implemented Interfaces:

AddressComponent, AddressSection, AddressSegmentSeries, AddressComponentRange, AddressDivisionSeries, AddressItem, AddressItemRange, AddressStringDivisionSeries, Serializable, Comparable<AddressItem>, Iterable<MACAddressSection>
```
public class MACAddressSection
extends AddressDivisionGrouping
implements AddressSection, Iterable<MACAddressSection>
```
A section of a MACAddress. It is a series of 0 to 8 individual MAC address segments that is aware of the segment index from within the address from which the section begins.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MACAddressSection.MACStringOptions
Represents a clear way to create a specific type of string.
- Nested classes/interfaces inherited from class inet.ipaddr.format.standard.AddressDivisionGrouping
  AddressDivisionGrouping.DivisionLengthProvider, AddressDivisionGrouping.DivisionValueProvider, AddressDivisionGrouping.StringOptions

Nested Classes
Modifier and Type	Class and Description
`static class`	`MACAddressSection.MACStringOptions` Represents a clear way to create a specific type of string.

Field Summary

Fields
Modifier and Type Field and Description

int addressSegmentIndex

boolean extended

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

Constructor Summary

Constructors
Constructor and Description
`MACAddressSection(Address.SegmentValueProvider valueProvider)`
`MACAddressSection(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, int startIndex, boolean extended)`
`MACAddressSection(Address.SegmentValueProvider valueProvider, int startIndex, boolean extended)`
`MACAddressSection(byte[] bytes)`
`MACAddressSection(byte[] bytes, int startIndex, boolean extended)`
`MACAddressSection(long value)`
`MACAddressSection(long value, int startIndex, boolean extended)`
`MACAddressSection(MACAddressSegment segment)` Constructs a single segment section, the segment being the leading segment.
`MACAddressSection(MACAddressSegment[] segments)` Use this constructor for any address section that includes the leading segment of a MAC address
`MACAddressSection(MACAddressSegment[] segments, int startIndex, boolean extended)`
`MACAddressSection(MACAddressSegment segment, int startIndex, boolean extended)` Constructs a single segment section with the segment at the given index in the address.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`MACAddressSection`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`MACAddressSection`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`MACAddressSection`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`MACAddressSection`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`MACAddressSection`	`append(MACAddressSection other)`
`MACAddressSection`	`appendToPrefix(MACAddressSection other)`
`MACAddressSection`	`applyPrefixLength(int prefixLength)` Deprecated.
`boolean`	`contains(AddressSection other)` Determines if one section contains another.
`boolean`	`contains(MACAddressSection other)`
`BigInteger`	`enumerate(AddressSection other)` Indicates where an address section sits relative to the ordering of individual address sections within this section.
`boolean`	`equals(Object o)` Two groupings are equal if: - they match type/version (ipv4, ipv6, mac, or a specific grouping class) - they match division counts - each division matches bit counts - each division matches their specific grouping class - each division matches values Prefix lengths, for those groupings and/or divisionsS that have them, are ignored.
`int`	`getBitCount()` Provides the number of bits comprising this address item
`int`	`getBitsPerSegment()` Returns the number of bits comprising each segment in this series.
`BigInteger`	`getBlockCount(int segmentCount)` Returns the count of values in the initial (higher) count of divisions.
`int`	`getByteCount()` Provides the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
`int`	`getBytesPerSegment()` Returns the number of bytes comprising each segment in this series.
`MACAddressSegment`	`getDivision(int index)`
`AddressDivisionGrouping`	`getDottedGrouping()`
`IPv6AddressNetwork`	`getIPv6Network()`
`Iterable<MACAddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`MACAddressSection`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`int`	`getMaxSegmentValue()` Returns the maximum possible segment value for this type of address.
`MACAddressNetwork`	`getNetwork()` Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`MACAddressSection`	`getODISection()`
`int`	`getODISegmentCount()`
`MACAddressSection`	`getOUISection()`
`int`	`getOUISegmentCount()`
`BigInteger`	`getPrefixCount(int prefixLength)` The count of the number of distinct values within the prefix part of the address item, the bits that appear within the prefix length.
`Integer`	`getPrefixLength()` The bit-length of the portion of the address that is not specific to an individual address but common amongst a group of addresses.
`MACAddressSection`	`getSection()` Gets the subsection from the series that comprises all segments
`MACAddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index The first segment is at index 0.
`MACAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex The first segment is at index 0.
`MACAddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`int`	`getSegmentCount()` Returns the number of segments in this series.
`MACAddressSegment[]`	`getSegments()` Returns the segments of this series of segments as an array.
`void`	`getSegments(AddressSegment[] segs)` Copies the existing segments into the given array.
`void`	`getSegments(Collection<? super MACAddressSegment> segs)`
`void`	`getSegments(int start, int end, AddressSegment[] segs, int destIndex)` get the segments from start to end and insert into the segs array at the given index
`void`	`getSegments(int start, int end, Collection<? super MACAddressSegment> segs)`
`String[]`	`getSegmentStrings()` Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
`MACAddressSection`	`getUpper()` If this represents a series with ranging values, returns a series representing the upper values of the range.
`MACAddressSection`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
`MACAddressSection`	`incrementBoundary(long increment)` If the given increment is positive, adds the value to the upper series (`AddressSegmentSeries.getUpper()`) in the subnet range to produce a new series.
`MACAddressSection`	`insert(int index, MACAddressSection other)`
`boolean`	`isEntireAddress(boolean extended)`
`boolean`	`isEUI64(boolean asMAC)` Equivalent to isEUI64(asMAC, false)
`boolean`	`isEUI64(boolean asMAC, 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 0xff/fe for MAC/not-MAC
`boolean`	`isExtended()`
`boolean`	`isPrefixed()` Indicates if the address represents all devices with the same OUI segments.
`Iterator<MACAddressSection>`	`iterator()` Iterates through the individual address components.
`long`	`longValue()`
`boolean`	`overlaps(AddressSection other)` Determines if one section overlaps with another.
`boolean`	`overlaps(MACAddressSection other)`
`Iterator<MACAddressSection>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`AddressComponentSpliterator<MACAddressSection>`	`prefixBlockSpliterator()` Partitions and traverses through the individual prefix blocks for the prefix length of this series.
`Stream<MACAddressSection>`	`prefixBlockStream()` Returns a sequential stream of the individual prefix blocks for the prefix length of this series.
`boolean`	`prefixEquals(AddressSection o)` Determines if the argument section matches this section up to the prefix length of this section.
`Iterator<MACAddressSection>`	`prefixIterator()` Iterates through the individual prefixes.
`AddressComponentSpliterator<MACAddressSection>`	`prefixSpliterator()` Partitions and traverses through the individual prefixes for the prefix length of this series.
`Stream<MACAddressSection>`	`prefixStream()` Returns a sequential stream of the individual prefixes for the prefix length of this series.
`MACAddressSection`	`removePrefixLength()` Deprecated.
`MACAddressSection`	`removePrefixLength(boolean zeroed)` Deprecated.
`MACAddressSection`	`replace(int startIndex, int endIndex, MACAddressSection 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
`MACAddressSection`	`replace(int index, MACAddressSection replacement)` Replace the segments of this section starting at the given index with the given replacement segments
`MACAddressSection`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`MACAddressSection`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`MACAddressSection`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`MACAddressSection`	`reverseSegments()` Returns a new segment series with the segments reversed.
`Iterator<MACAddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`AddressComponentRangeSpliterator<MACAddressSection,MACAddressSegment[]>`	`segmentsSpliterator()` Partitions and traverses through the individual segment arrays.
`Stream<MACAddressSegment[]>`	`segmentsStream()` Returns a sequential stream of the individual segment arrays.
`MACAddressSection`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`MACAddressSection`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`AddressComponentSpliterator<MACAddressSection>`	`spliterator()` Partitions and traverses through the individual address components.
`Stream<MACAddressSection>`	`stream()` Returns a sequential stream of the individual address components.
`String`	`toCanonicalString()` This produces a canonical string using the canonical standardized IEEE 802 MAC address representation of xx-xx-xx-xx-xx-xx For range segments, '..' is used: 11-22-33..44-55-66
`String`	`toColonDelimitedString()`
`String`	`toCompressedString()` This produces a shorter string for the address that uses the canonical representation but not using leading zeroes.
`String`	`toDashedString()`
`String`	`toDottedString()` This produces the dotted hexadecimal format aaaa.bbbb.cccc
`MACAddressSection`	`toEUI64(boolean asMAC)` If this section is part of a shorter 48 bit MAC or EUI-48 address see `isExtended()`, then the required sections are inserted (FF-FF for MAC, FF-FE for EUI-48) to extend it to EUI-64.
`IPv6AddressSection`	`toEUI64IPv6()` Converts to Ipv6.
`String`	`toHexString(boolean with0xPrefix)` Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`String`	`toNormalizedString()` The normalized string returned by this method is the most common representation of MAC addresses: xx:xx:xx:xx:xx:xx
`String`	`toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)`
`static String`	`toNormalizedString(AddressDivisionGrouping.StringOptions opts, AddressDivisionGrouping section)`
`MACAddressSection`	`toOUIPrefixBlock()` Returns a section in which the range of values match the block for the OUI (organizationally unique identifier) bytes
`MACAddressSection`	`toPrefixBlock()` If this series has a prefix length, returns the block for that prefix.
`String`	`toSpaceDelimitedString()` This produces a string delimited by spaces: aa bb cc dd ee ff
`String`	`toString()`
`long`	`upperLongValue()`
`MACAddressSection`	`withoutPrefixLength()` Provides the same address with no prefix.

Methods inherited from class inet.ipaddr.format.standard.AddressDivisionGrouping
containsPrefixBlock, containsSinglePrefixBlock, hashCode

Methods inherited from class inet.ipaddr.format.AddressDivisionGroupingBase
getBytes, getBytes, getBytes, getCount, getDivisionCount, getDivisionStrings, getMinPrefixLengthForBlock, getPrefixCount, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, includesMax, includesZero, isFullRange, isMax, isMultiple, isPrefixBlock, isSequential, isSinglePrefixBlock, isZero

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

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
isOneBit, testBit

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getCount, getDivisionStrings, getPrefixCount, getSequentialBlockIndex, isMore, isPrefixBlock, isSequential, isSinglePrefixBlock

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

Methods inherited from interface inet.ipaddr.format.AddressComponentRange
stream, stream

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBitsForCount, getBlockSize, getBytes, getBytes, getBytes, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, includesMax, includesZero, isFullRange, isMax, isMultiple, isZero

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - addressSegmentIndex
```
public final int addressSegmentIndex
```
  - extended
```
public final boolean extended
```
- Constructor Detail
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment segment)
```
    Constructs a single segment section, the segment being the leading segment.
    
    Parameters:
    
    segment -
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment segment,
                         int startIndex,
                         boolean extended)
```
    Constructs a single segment section with the segment at the given index in the address.
    
    Parameters:
    
    segment -
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments)
```
    Use this constructor for any address section that includes the leading segment of a MAC address
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(Address.SegmentValueProvider valueProvider)
```
  - MACAddressSection
```
public MACAddressSection(Address.SegmentValueProvider valueProvider,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(Address.SegmentValueProvider lowerValueProvider,
                         Address.SegmentValueProvider upperValueProvider,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes)
```
  - MACAddressSection
```
public MACAddressSection(long value,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(long value)
```
- Method Detail
  - getNetwork
```
public MACAddressNetwork getNetwork()
```
    Description copied from interface: AddressComponent
    
    Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressComponent
    
    Returns:
  - getIPv6Network
```
public IPv6AddressNetwork getIPv6Network()
```
  - equals
```
public boolean equals(Object o)
```
    Description copied from class: AddressDivisionGroupingBase
    
    Two groupings are equal if: - they match type/version (ipv4, ipv6, mac, or a specific grouping class) - they match division counts - each division matches bit counts - each division matches their specific grouping class - each division matches values Prefix lengths, for those groupings and/or divisionsS that have them, are ignored.
    
    Overrides:
    
    equals in class AddressDivisionGrouping
  - getSegments
```
public MACAddressSegment[] 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
    
    Returns:
  - getSegments
```
public void getSegments(AddressSegment[] segs)
```
    Description copied from interface: AddressSegmentSeries
    
    Copies the existing segments into the given array. The array size should be at least as large as AddressSegmentSeries.getSegmentCount()
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(int start,
                        int end,
                        AddressSegment[] segs,
                        int destIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    get the segments from start to end and insert into the segs array at the given index
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Parameters:
    
    start - the first segment index from this series to be included
    
    end - the first segment index to be excluded
    
    segs - the target array
    
    destIndex - where to insert the segments in the segs array
  - isExtended
```
public boolean isExtended()
```
    Returns:
    
    whether this section is part of a larger EUI-64 address.
  - getSegmentCount
```
public int getSegmentCount()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of segments in this series.
    
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
    
    Returns:
  - isEntireAddress
```
public boolean isEntireAddress(boolean extended)
```
  - getDivision
```
public MACAddressSegment getDivision(int index)
```
    Specified by:
    
    getDivision in interface AddressDivisionSeries
    
    Specified by:
    
    getDivision in interface AddressStringDivisionSeries
    
    Overrides:
    
    getDivision in class AddressDivisionGrouping
    
    Returns:
    
    the given division in this series. The first is at index 0.
  - getSegment
```
public MACAddressSegment getSegment(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segment from this series at the given index. The first segment is at index 0. A segment is an address division, see AddressDivisionSeries.getDivision(int), the difference being that all segments in a given series are the same bit count, while divisions can have variable length.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
public void getSegments(Collection<? super MACAddressSegment> segs)
```
  - getSegments
```
public void getSegments(int start,
                        int end,
                        Collection<? super MACAddressSegment> segs)
```
  - getMaxSegmentValue
```
public int getMaxSegmentValue()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the maximum possible segment value for this type of address. Note this is not the maximum value of the range of segment values in this specific address, this is the maximum value of any segment for this address type, and is usually determined by the number of bits per segment.
    
    Specified by:
    
    getMaxSegmentValue in interface AddressSegmentSeries
    
    Returns:
    
    the maximum possible segment value for a series of the same type
  - 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:
  - getByteCount
```
public int getByteCount()
```
    Description copied from interface: AddressItem
    
    Provides the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
    
    Specified by:
    
    getByteCount in interface AddressItem
    
    Returns:
    
    the number of bytes
  - getBitCount
```
public int getBitCount()
```
    Description copied from interface: AddressItem
    
    Provides the number of bits comprising this address item
    
    Specified by:
    
    getBitCount in interface AddressDivisionSeries
    
    Specified by:
    
    getBitCount in interface AddressItem
    
    Returns:
    
    the number of bits
  - getBlockCount
```
public BigInteger getBlockCount(int segmentCount)
```
    Description copied from interface: AddressDivisionSeries
    
    Returns the count of values in the initial (higher) count of divisions.
    
    Specified by:
    
    getBlockCount in interface AddressDivisionSeries
    
    Returns:
  - getPrefixCount
```
public BigInteger getPrefixCount(int prefixLength)
```
    Description copied from interface: AddressItem
    
    The count of the number of distinct values within the prefix part of the address item, the bits that appear within the prefix length.
    
    Specified by:
    
    getPrefixCount in interface AddressDivisionSeries
    
    Specified by:
    
    getPrefixCount in interface AddressItem
    
    Returns:
  - isPrefixed
```
public boolean isPrefixed()
```
    Indicates if the address represents all devices with the same OUI segments.
    
    Specified by:
    
    isPrefixed in interface AddressDivisionSeries
    
    Overrides:
    
    isPrefixed in class AddressDivisionGroupingBase
    
    Returns:
    
    true if all the ODI segments are full-range, covering all devices
  - getOUISegmentCount
```
public int getOUISegmentCount()
```
  - getODISegmentCount
```
public int getODISegmentCount()
```
  - getPrefixLength
```
public Integer getPrefixLength()
```
    Description copied from interface: AddressDivisionSeries
    
    The bit-length of the portion of the address that is not specific to an individual address but common amongst a group of addresses.
    Typically this is the largest number of bits in the upper-most portion of the section for which the remaining bits assume all possible values.
    For IP addresses, this must be explicitly defined when the address is created. For example, 1.2.0.0/16 has a prefix length of 16, while 1.2.*.* has no prefix length, even though they both represent the same set of addresses and are considered equal. Prefixes can be considered variable for any given IP addresses and can depend on the routing table.
    The methods AddressItem.getMinPrefixLengthForBlock() and AddressItem.getPrefixLengthForSingleBlock() can help you to obtain or define a prefix length if one does not exist already. 1.2.0.0/16 and 1.2.*.* both the same equivalent and minimum prefix length of 16.
    For MAC addresses, the prefix is initially defined by the range, so 1:2:3:*:*:* has a prefix length of 24 by definition. Addresses derived from the original may retain the original prefix length regardless of their range.
    
    Specified by:
    
    getPrefixLength in interface AddressDivisionSeries
    
    Overrides:
    
    getPrefixLength in class AddressDivisionGroupingBase
    
    Returns:
    
    the number of bits in the prefix. The prefix is the smallest bit length x for which all possible values with the same first x bits are included in this range of sections, unless that value x matches the bit count of this section, in which case the prefix is null. If the prefix is the OUI bit length (24) then the ODI segments cover all possibly values.
  - getSection
```
public MACAddressSection getSection()
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series that comprises all segments
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
public MACAddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
public MACAddressSection 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 The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getOUISection
```
public MACAddressSection getOUISection()
```
  - getODISection
```
public MACAddressSection getODISection()
```
  - toOUIPrefixBlock
```
public MACAddressSection toOUIPrefixBlock()
```
    Returns a section in which the range of values match the block for the OUI (organizationally unique identifier) bytes
    
    Returns:
  - toEUI64IPv6
```
public IPv6AddressSection toEUI64IPv6()
```
    Converts to Ipv6. Any MAC prefix length is ignored. Other elements of this address section are incorporated into the conversion.
    
    Returns:
  - isEUI64
```
public boolean isEUI64(boolean asMAC)
```
    Equivalent to isEUI64(asMAC, false)
    
    Returns:
  - isEUI64
```
public boolean isEUI64(boolean asMAC,
                       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 0xff/fe for MAC/not-MAC
    
    Parameters:
    
    partial - whether missing segments are considered a match (this only has an effect if this section came from an extended 8 byte address), or in other words, we don't consider 6 byte addresses to be "missing" the bytes that would make it 8 byte.
    
    asMAC - whether to search for the ffff or fffe pattern
    
    Returns:
  - toEUI64
```
public MACAddressSection toEUI64(boolean asMAC)
```
    If this section is part of a shorter 48 bit MAC or EUI-48 address see isExtended(), then the required sections are inserted (FF-FF for MAC, FF-FE for EUI-48) to extend it to EUI-64. However, if the section does not encompass the parts of the address where the new sections should be placed, then the section is unchanged. If the section is already part of an EUI-64 address, then it is checked to see if it has the segments that identify it as extended to EUI-64 (FF-FF for MAC, FF-FE for EUI-48), and if not, IncompatibleAddressException is thrown.
    
    Parameters:
    
    asMAC -
    
    Returns:
  - append
```
public MACAddressSection append(MACAddressSection other)
```
  - appendToPrefix
```
public MACAddressSection appendToPrefix(MACAddressSection other)
```
  - insert
```
public MACAddressSection insert(int index,
                                MACAddressSection other)
```
  - replace
```
public MACAddressSection replace(int index,
                                 MACAddressSection replacement)
```
    Replace the segments of this section starting at the given index with the given replacement segments
    
    Parameters:
    
    index -
    
    replacement -
    
    Returns:
  - replace
```
public MACAddressSection replace(int startIndex,
                                 int endIndex,
                                 MACAddressSection 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:
    
    IndexOutOfBoundsException
    
    AddressValueException - if the resulting section would exceed the maximum segment count for this address type and version
  - getLower
```
public MACAddressSection 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 AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Specified by:
    
    getLower in interface AddressComponentRange
    
    Returns:
  - getUpper
```
public MACAddressSection 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 AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Specified by:
    
    getUpper in interface AddressComponentRange
    
    Returns:
  - longValue
```
public long longValue()
```
  - upperLongValue
```
public long upperLongValue()
```
  - reverseBits
```
public MACAddressSection reverseBits(boolean perByte)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bits reversed.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSection
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public MACAddressSection reverseBytes()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Specified by:
    
    reverseBytes in interface AddressSection
    
    Specified by:
    
    reverseBytes in interface AddressSegmentSeries
    
    Returns:
  - reverseBytesPerSegment
```
public MACAddressSection reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSection
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - reverseSegments
```
public MACAddressSection 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
    
    Returns:
  - removePrefixLength
```
@Deprecated
public MACAddressSection removePrefixLength()
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length while zeroing out the bits beyond the prefix.
    If the series already has a prefix length, the bits outside the prefix become zero. Use AddressSegmentSeries.withoutPrefixLength() to remove the prefix length without changing the series values.
    Equivalent to calling removePrefixLength(true)
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
    
    See Also:
    
    for an alternative which does not change the address series values.
  - withoutPrefixLength
```
public MACAddressSection withoutPrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Provides the same address with no prefix. The values remain unchanged.
    Use AddressSegmentSeries.removePrefixLength() as an alternative that deletes the host at the same time by zeroing the host values.
    
    Specified by:
    
    withoutPrefixLength in interface AddressSection
    
    Specified by:
    
    withoutPrefixLength in interface AddressSegmentSeries
  - removePrefixLength
```
@Deprecated
public MACAddressSection removePrefixLength(boolean zeroed)
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length. If zeroed is false, the bits that were host bits do not become zero, unlike AddressSegmentSeries.removePrefixLength()
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - adjustPrefixBySegment
```
public MACAddressSection 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. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixBySegment(boolean, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    Returns:
  - adjustPrefixBySegment
```
public MACAddressSection 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
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    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 MACAddressSection 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. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixLength(int, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
public MACAddressSection 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
    
    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
```
@Deprecated
public MACAddressSection applyPrefixLength(int prefixLength)
```
    Deprecated.
    
    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
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - setPrefixLength
```
public MACAddressSection setPrefixLength(int prefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    If this series has a prefix length, and the prefix length is increased, the bits moved within the prefix become zero. For an alternative that does not set bits to zero, use AddressSegmentSeries.setPrefixLength(int, boolean) with the second argument as false.
    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
    
    Returns:
  - setPrefixLength
```
public MACAddressSection setPrefixLength(int prefixLength,
                                         boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSection
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    zeroed - whether the bits that move from one side of the prefix length to the other (ie bits moved into the prefix or outside the prefix) are zeroed.
    
    Returns:
  - toPrefixBlock
```
public MACAddressSection toPrefixBlock()
```
    Description copied from interface: AddressSegmentSeries
    
    If this series has a prefix length, returns the block for that prefix. Otherwise, this address series is returned.
    
    Specified by:
    
    toPrefixBlock in interface AddressSection
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Returns:
    
    the block of address series for the prefix length
  - getIterable
```
public Iterable<MACAddressSection> getIterable()
```
    Description copied from interface: AddressComponentRange
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponentRange.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressSection
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Specified by:
    
    getIterable in interface AddressComponentRange
    
    Returns:
  - iterator
```
public Iterator<MACAddressSection> iterator()
```
    Description copied from interface: AddressComponentRange
    
    Iterates through the individual address components.
    An address component can represent an individual segment, address, or section, or it can represent multiple, typically a subnet of addresses or a range of segment or section values.
    Call AddressItem.isMultiple() to determine if this instance represents multiple, or AddressItem.getCount() for the count.
    
    Specified by:
    
    iterator in interface AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface AddressComponentRange
    
    Specified by:
    
    iterator in interface Iterable<MACAddressSection>
  - prefixIterator
```
public Iterator<MACAddressSection> prefixIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual prefixes.
    If the series has no prefix length, then this is equivalent to AddressSegmentSeries.iterator()
    
    Specified by:
    
    prefixIterator in interface AddressSection
    
    Specified by:
    
    prefixIterator in interface AddressSegmentSeries
  - prefixBlockIterator
```
public Iterator<MACAddressSection> 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
  - segmentsIterator
```
public Iterator<MACAddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
  - segmentsSpliterator
```
public AddressComponentRangeSpliterator<MACAddressSection,MACAddressSegment[]> segmentsSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual segment arrays.
    
    Specified by:
    
    segmentsSpliterator in interface AddressSegmentSeries
    
    Returns:
  - segmentsStream
```
public Stream<MACAddressSegment[]> segmentsStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual segment arrays. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    segmentsStream in interface AddressSegmentSeries
    
    Returns:
  - spliterator
```
public AddressComponentSpliterator<MACAddressSection> spliterator()
```
    Description copied from interface: AddressComponentRange
    
    Partitions and traverses through the individual address components.
    
    Specified by:
    
    spliterator in interface AddressComponent
    
    Specified by:
    
    spliterator in interface AddressSection
    
    Specified by:
    
    spliterator in interface AddressSegmentSeries
    
    Specified by:
    
    spliterator in interface AddressComponentRange
    
    Specified by:
    
    spliterator in interface Iterable<MACAddressSection>
  - stream
```
public Stream<MACAddressSection> stream()
```
    Description copied from interface: AddressComponentRange
    
    Returns a sequential stream of the individual address components. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    stream in interface AddressSection
    
    Specified by:
    
    stream in interface AddressSegmentSeries
    
    Specified by:
    
    stream in interface AddressComponentRange
    
    Returns:
  - prefixSpliterator
```
public AddressComponentSpliterator<MACAddressSection> prefixSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefixes for the prefix length of this series.
    
    Specified by:
    
    prefixSpliterator in interface AddressSection
    
    Specified by:
    
    prefixSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixStream
```
public Stream<MACAddressSection> prefixStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefixes for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixStream in interface AddressSection
    
    Specified by:
    
    prefixStream in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockSpliterator
```
public AddressComponentSpliterator<MACAddressSection> prefixBlockSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefix blocks for the prefix length of this series.
    
    Specified by:
    
    prefixBlockSpliterator in interface AddressSection
    
    Specified by:
    
    prefixBlockSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockStream
```
public Stream<MACAddressSection> prefixBlockStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefix blocks for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixBlockStream in interface AddressSection
    
    Specified by:
    
    prefixBlockStream in interface AddressSegmentSeries
    
    Returns:
  - incrementBoundary
```
public MACAddressSection incrementBoundary(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    If the given increment is positive, adds the value to the upper series (AddressSegmentSeries.getUpper()) in the subnet range to produce a new series. If the given increment is negative, adds the value to the lower series (AddressSegmentSeries.getLower()) in the subnet range to produce a new series. If the increment is zero, returns this.
    In the case where the series is a single value, this simply returns the address produced by adding the given increment to this address series.
    
    Specified by:
    
    incrementBoundary in interface AddressSection
    
    Specified by:
    
    incrementBoundary in interface AddressSegmentSeries
    
    Returns:
  - increment
```
public MACAddressSection increment(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which it exceeds the size - 1 is added to the upper series of the range (the final iterator value).
    If the increment is negative, it is added to the lower series of the range (the first iterator value).
    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 AddressSegmentSeries.iterator() For instance, a increment of 0 is the first value from the iterator, an increment of 1 is the second value from the iterator, and so on. A negative increment added to the subnet count is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of count - 1 is the last value from the iterator, an increment of count - 2 is the second last value, and so on.
    An increment of size count gives you the series just above the highest series of the subnet. To get the series just below the lowest series of the subnet, use the increment -1.
    
    Specified by:
    
    increment in interface AddressSection
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Returns:
  - toHexString
```
public String toHexString(boolean with0xPrefix)
                   throws IncompatibleAddressException
```
    Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
    
    Specified by:
    
    toHexString in interface AddressComponent
    
    Throws:
    
    IncompatibleAddressException
  - toNormalizedString
```
public String toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)
```
  - toNormalizedString
```
public static String toNormalizedString(AddressDivisionGrouping.StringOptions opts,
                                        AddressDivisionGrouping section)
```
  - toNormalizedString
```
public String toNormalizedString()
```
    The normalized string returned by this method is the most common representation of MAC addresses: xx:xx:xx:xx:xx:xx
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toCanonicalString
```
public String toCanonicalString()
```
    This produces a canonical string using the canonical standardized IEEE 802 MAC address representation of xx-xx-xx-xx-xx-xx For range segments, '..' is used: 11-22-33..44-55-66
    
    Specified by:
    
    toCanonicalString in interface AddressSegmentSeries
    
    Returns:
  - toCompressedString
```
public String toCompressedString()
```
    This produces a shorter string for the address that uses the canonical representation but not using leading zeroes. Each address has a unique compressed string.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Returns:
  - toDottedString
```
public String toDottedString()
                      throws IncompatibleAddressException
```
    This produces the dotted hexadecimal format aaaa.bbbb.cccc
    
    Throws:
    
    IncompatibleAddressException
  - toSpaceDelimitedString
```
public String toSpaceDelimitedString()
```
    This produces a string delimited by spaces: aa bb cc dd ee ff
  - toDashedString
```
public String toDashedString()
```
  - toColonDelimitedString
```
public String toColonDelimitedString()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AddressDivisionGroupingBase
  - getSegmentStrings
```
public String[] getSegmentStrings()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
    
    Specified by:
    
    getSegmentStrings in interface AddressSegmentSeries
    
    Returns:
  - getDottedGrouping
```
public AddressDivisionGrouping getDottedGrouping()
```
  - overlaps
```
public boolean overlaps(AddressSection other)
```
    Description copied from interface: AddressSection
    
    Determines if one section overlaps with 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:
    
    overlaps in interface AddressSection
    
    Returns:
    
    whether this section overlaps with the given address section
  - overlaps
```
public boolean overlaps(MACAddressSection other)
```
    Parameters:
    
    other -
    
    Returns:
    
    whether this section contains the given address section
  - 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
  - contains
```
public boolean contains(MACAddressSection other)
```
    Parameters:
    
    other -
    
    Returns:
    
    whether this section contains the given address section
  - enumerate
```
public BigInteger enumerate(AddressSection other)
```
    Description copied from interface: AddressSection
    Indicates where an address section sits relative to the ordering of individual address sections within this section.
    Determines how many address section elements precede the given address section element, if the given address section is within this address section. If above the range, it is the distance to the upper boundary added to the address section count, and if below the range, the distance to the lower boundary.
    In other words, if the given address section is not in this section but above it, returns the number of individual address sections preceding the given address section from the upper section boundary, added to the total number of individual address sections within. If the given address section is not in this section but below it, returns the number of individual address sections following the given address section to the lower section boundary.
    enumerate returns null when the argument is a multi-valued section. The argument must be an individual address section.
    When this address section is also single-valued, the returned value is the distance (difference) between this address section and the argument address section.
    enumerate is the inverse of the increment method:
    - section.enumerate(section.increment(inc)) = inc
    - section.increment(section.enumerate(individualSection)) = individualSection
    If the given address section does not have the same version or type as this address section, then null is returned. If the given address section is the same version and type, but has a different segment count, then SizeMismatchException is thrown.
    Specified by:
    
    enumerate in interface AddressSection
  - prefixEquals
```
public boolean prefixEquals(AddressSection o)
```
    Description copied from interface: AddressSection
    
    Determines if the argument section matches this section up to the prefix length of this section.
    The entire prefix of this section must be present in the other section to be comparable.
    For sections which are aware of their position in an address (IPv6 and MAC), the argument section must have the same or an earlier position in the address to match all prefix segments of this section, and the matching is lined up relative to the position.
    
    Specified by:
    
    prefixEquals in interface AddressSection
    
    Returns:
    
    whether the argument section has the same address section prefix as this

Class MACAddressSection

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class inet.ipaddr.format.standard.AddressDivisionGrouping

Methods inherited from class inet.ipaddr.format.AddressDivisionGroupingBase

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

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

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

Methods inherited from interface java.lang.Iterable

Field Detail

addressSegmentIndex

extended

Constructor Detail

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

Method Detail

getNetwork

getIPv6Network

equals

getSegments

getSegments

getSegments

isExtended

getSegmentCount

isEntireAddress

getDivision

getSegment

getSegments

getSegments

getMaxSegmentValue

getBitsPerSegment

getBytesPerSegment

getByteCount

getBitCount

getBlockCount

getPrefixCount

isPrefixed

getOUISegmentCount

getODISegmentCount

getPrefixLength

getSection

getSection

getSection

getOUISection

getODISection

toOUIPrefixBlock

toEUI64IPv6

isEUI64

isEUI64

toEUI64

append

appendToPrefix

insert

replace

replace

getLower

getUpper

longValue

upperLongValue

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

removePrefixLength

withoutPrefixLength