MACAddressSection

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

All Implemented Interfaces:

AddressComponent, AddressSection, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressStringDivisionSeries, java.io.Serializable, java.lang.Comparable<AddressDivisionGrouping>, java.lang.Iterable<MACAddressSection>
```
public class MACAddressSection
extends AddressDivisionGrouping
implements AddressSection, java.lang.Iterable<MACAddressSection>
```
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.AddressDivisionGrouping
  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
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)` Applies the given prefix length to create a new segment series.
`boolean`	`contains(AddressSection other)` Determines if one section contains another.
`boolean`	`contains(MACAddressSection other)`
`boolean`	`equals(java.lang.Object o)`
`int`	`getBitCount()`
`int`	`getBitsPerSegment()` Returns the number of bits comprising each segment in this series.
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`int`	`getBytesPerSegment()` Returns the number of bytes comprising each segment in this series.
`MACAddressSegment`	`getDivision(int index)`
`AddressDivisionGrouping`	`getDottedGrouping()`
`IPv6AddressNetwork`	`getIPv6Network()`
`java.lang.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.
`MACAddressNetwork`	`getNetwork()` Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`MACAddressSection`	`getODISection()`
`int`	`getODISegmentCount()`
`MACAddressSection`	`getOUISection()`
`int`	`getOUISegmentCount()`
`java.math.BigInteger`	`getPrefixCount()` If this has a prefix length, the count of the range of values in the prefix.
`java.lang.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
`MACAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`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(java.util.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 the given index
`void`	`getSegments(int start, int end, java.util.Collection<? super MACAddressSegment> segs)`
`java.lang.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 If this represents a series with a single value in each segment, returns this.
`MACAddressSection`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this.
`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.
`java.util.Iterator<MACAddressSection>`	`iterator()` Iterates through the individual segment series.
`long`	`longValue()`
`java.util.Iterator<MACAddressSection>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`MACAddressSection`	`removePrefixLength()` Removes the prefix length.
`MACAddressSection`	`removePrefixLength(boolean zeroed)` Removes the prefix length.
`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.
`java.util.Iterator<MACAddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`MACAddressSection`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`MACAddressSection`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`java.lang.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
`java.lang.String`	`toColonDelimitedString()`
`java.lang.String`	`toCompressedString()` This produces a shorter string for the address that uses the canonical representation but not using leading zeroes.
`java.lang.String`	`toDashedString()`
`java.lang.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.
`java.lang.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.
`java.lang.String`	`toNormalizedString()` The normalized string returned by this method is the most common representation of MAC addresses: xx:xx:xx:xx:xx:xx
`java.lang.String`	`toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)`
`static java.lang.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.
`java.lang.String`	`toSpaceDelimitedString()` This produces a string delimited by spaces: aa bb cc dd ee ff
`java.lang.String`	`toString()`
`long`	`upperLongValue()`

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBytes, getBytes, getCount, getDivisionCount, getDivisionStrings, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperValue, getValue, hashCode, includesMax, includesZero, isFullRange, isMax, isMore, isMultiple, isPrefixBlock, isSinglePrefixBlock, isZero

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

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
containsPrefixBlock, containsSinglePrefixBlock, getDivisionStrings, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperValue, getValue, isMore, isPrefixBlock, isSinglePrefixBlock

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

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

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

- 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: AddressSegmentSeries
    
    Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressSegmentSeries
    
    Returns:
  - getIPv6Network
```
public IPv6AddressNetwork getIPv6Network()
```
  - equals
```
public boolean equals(java.lang.Object o)
```
    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 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.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
public void getSegments(java.util.Collection<? super MACAddressSegment> segs)
```
  - getSegments
```
public void getSegments(int start,
                        int end,
                        java.util.Collection<? super MACAddressSegment> segs)
```
  - 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: AddressComponent
    
    returns the number of bytes in each of the address components represented by this instance
    
    Specified by:
    
    getByteCount in interface AddressComponent
    
    Returns:
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class AddressDivisionGrouping
    
    Returns:
    
    the number of bits comprising this address item
  - getPrefixCount
```
public java.math.BigInteger getPrefixCount()
```
    Description copied from interface: AddressDivisionSeries
    
    If this has a prefix length, the count of the range of values in the prefix.
    If this has no prefix length, returns the same value as AddressItem.getCount()
    
    Specified by:
    
    getPrefixCount in interface AddressDivisionSeries
    
    Overrides:
    
    getPrefixCount in class AddressDivisionGrouping
    
    Returns:
  - 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 AddressDivisionGrouping
    
    Returns:
    
    true if all the ODI segments are full-range, covering all devices
  - getOUISegmentCount
```
public int getOUISegmentCount()
```
  - getODISegmentCount
```
public int getODISegmentCount()
```
  - getPrefixLength
```
public java.lang.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 AddressDivisionSeries.getMinPrefixLengthForBlock() and AddressDivisionSeries.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 AddressDivisionGrouping
    
    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
    
    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
    
    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:
    
    java.lang.IndexOutOfBoundsException
    
    AddressValueException - if the resulting section would exceed the maximum segment count for this address type and version
  - contains
```
public boolean contains(MACAddressSection other)
```
    Parameters:
    
    other -
    
    Returns:
    
    whether this section contains the given address section
  - 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 AddressComponent
    
    Specified by:
    
    getLower in interface AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    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 AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    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
```
public MACAddressSection removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    If the series already has a prefix length, the bits outside the prefix become zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
  - removePrefixLength
```
public MACAddressSection removePrefixLength(boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    
    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.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    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 coundary
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - adjustPrefixLength
```
public 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.
    
    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
```
public MACAddressSection applyPrefixLength(int prefixLength)
```
    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.
    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:
    
    See Also:
    
    AddressSegmentSeries.applyPrefixLength(int)
  - 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 java.lang.Iterable<MACAddressSection> 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
    
    Returns:
  - iterator
```
public java.util.Iterator<MACAddressSection> iterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segment series. The resulting elements will not have an assigned prefix.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface java.lang.Iterable<MACAddressSection>
  - prefixBlockIterator
```
public java.util.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 java.util.Iterator<MACAddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
  - 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, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this. If the increment is 0, then this series is returned.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which is exceeds the size is added to the upper series of the range (the final iterator value) or is subtracted from the lower series of the range (the first iterator value) if negative.
    If the subnet is just a single address values, the series is simply incremented by the given value, positive or negative.
    If a subnet has multiple values, a positive increment value is equivalent to the same number of values from the iterator. For instance, a increment of 1 is value 1 from the iterator, an increment of 2 is the second value from the iterator, and so on. A negative increment is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of -1 is the last value from the iterator, and increment of -2 is the second last value, and so on.
    Therefore, to get the series just above the highest series of the subnet, use an increment of size:count > 1 ? count + 1 : 1 where count is the subnet size. To get the series just below the lowest series of the subnet, use an increment of size:-(count > 1 ? count + 1 : 1) where count is the subnet size.
    
    Specified by:
    
    increment in interface AddressSection
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Returns:
  - toHexString
```
public java.lang.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.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public java.lang.String toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)
```
  - toNormalizedString
```
public static java.lang.String toNormalizedString(AddressDivisionGrouping.StringOptions opts,
                                                  AddressDivisionGrouping section)
```
  - toNormalizedString
```
public java.lang.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 java.lang.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 java.lang.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 java.lang.String toDottedString()
```
    This produces the dotted hexadecimal format aaaa.bbbb.cccc
  - toSpaceDelimitedString
```
public java.lang.String toSpaceDelimitedString()
```
    This produces a string delimited by spaces: aa bb cc dd ee ff
  - toDashedString
```
public java.lang.String toDashedString()
```
  - toColonDelimitedString
```
public java.lang.String toColonDelimitedString()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class AddressDivisionGrouping
  - getSegmentStrings
```
public java.lang.String[] getSegmentStrings()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
    
    Specified by:
    
    getSegmentStrings in interface AddressSegmentSeries
    
    Returns:
  - getDottedGrouping
```
public AddressDivisionGrouping getDottedGrouping()
```
  - 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

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

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressItem

Methods inherited from interface java.lang.Iterable

addressSegmentIndex

extended

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

getNetwork

getIPv6Network

equals

getSegments

getSegments

getSegments

isExtended

getSegmentCount

isEntireAddress

getDivision

getSegment

getSegments

getSegments

getBitsPerSegment

getBytesPerSegment

getByteCount

getBitCount

getPrefixCount

isPrefixed

getOUISegmentCount

getODISegmentCount

getPrefixLength

getSection

getSection

getSection

getOUISection

getODISection

toOUIPrefixBlock

toEUI64IPv6

isEUI64

isEUI64

toEUI64

append

appendToPrefix

insert

replace

replace

contains

getLower

getUpper

longValue

upperLongValue

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

removePrefixLength

removePrefixLength

adjustPrefixBySegment

adjustPrefixBySegment

adjustPrefixLength

adjustPrefixLength

applyPrefixLength

setPrefixLength

setPrefixLength

toPrefixBlock

getIterable

iterator

prefixBlockIterator

segmentsIterator