IPAddressSegment

java.lang.Object
- inet.ipaddr.format.AddressDivisionBase
- - inet.ipaddr.format.AddressDivision
  - - inet.ipaddr.format.IPAddressDivision
    - - inet.ipaddr.IPAddressSegment

All Implemented Interfaces:

AddressComponent, AddressSegment, AddressItem, AddressStringDivision, java.io.Serializable, java.lang.Comparable<AddressDivision>

Direct Known Subclasses:

IPv4AddressSegment, IPv6AddressSegment
```
public abstract class IPAddressSegment
extends IPAddressDivision
implements AddressSegment
```
This represents a single segment of an IP address. For IPv4, segments are 1 byte. For IPv6, they are two bytes. IPAddressSegment objects are immutable and thus also thread-safe.

See Also:

Serialized Form

Field Summary
- Fields inherited from class inet.ipaddr.format.IPAddressDivision
  ADJUST_RANGES_BY_PREFIX

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`contains(AddressSegment other)`
`static int`	`getBitCount(IPAddress.IPVersion version)`
`static int`	`getByteCount(IPAddress.IPVersion version)`
`static int`	`getDefaultTextualRadix(IPAddress.IPVersion version)`
`long`	`getDivisionValueCount()`
`abstract IPAddress.IPVersion`	`getIPVersion()`
`abstract java.lang.Iterable<? extends IPAddressSegment>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract IPAddressSegment`	`getLower()` If this segment represents a range of values, returns a segment representing just the lowest value in the range, otherwise returns this.
`int`	`getLowerSegmentValue()` returns the lower value
`long`	`getLowerValue()` returns the lower value as a long, although for individual segments `getLowerSegmentValue()` provides the same value as an int
`static int`	`getMaxSegmentValue(IPAddress.IPVersion version)`
`long`	`getMaxValue()`
`int`	`getMinPrefix()`
`java.lang.Integer`	`getSegmentPrefixLength()`
`abstract IPAddressSegment`	`getUpper()` If this segment represents a range of values, returns a segment representing just the highest value in the range, otherwise returns this.
`int`	`getUpperSegmentValue()` returns the upper value
`long`	`getUpperValue()` returns the lower upper value as a long, although for individual segments `getUpperSegmentValue()` provides the same value as an int
`int`	`getValueCount()`
`int`	`hashCode()`
`boolean`	`isBoundedBy(int value)` Returns true if the possible values of this division fall below the given value.
`boolean`	`isFullRange()`
`static boolean`	`isFullRange(int lower, int upper, java.lang.Integer prefix, IPAddress.IPVersion version)`
`static boolean`	`isFullRange(int lower, int upper, IPAddress.IPVersion version)`
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`boolean`	`isMaskCompatibleWithRange(int maskValue, java.lang.Integer segmentPrefix)`
`boolean`	`isMaskCompatibleWithRange(IPAddressSegment maskSegment, java.lang.Integer segmentPrefixLength)` Check that the range resulting from the mask is contiguous, otherwise we cannot represent it.
`boolean`	`isMultiple()` Whether this represents multiple potential values (eg a prefixed address or a segment representing a range of values)
`abstract java.util.Iterator<? extends IPAddressSegment>`	`iterator()` An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values.
`boolean`	`matches(int value)`
`boolean`	`matchesWithMask(int value, int mask)`
`boolean`	`matchesWithPrefix(int value, java.lang.Integer segmentPrefixLength)`
`abstract IPAddressSegment`	`removePrefixLength()`
`abstract IPAddressSegment`	`removePrefixLength(boolean zeroed)`
`abstract IPAddressSegment`	`reverseBits(boolean perByte)` Returns a new AddressComponent with the bits reversed.
`abstract IPAddressSegment`	`reverseBytes()` Returns an AddressComponent with the bytes reversed.
`java.lang.String`	`toHexString(boolean with0xPrefix)` Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`abstract IPAddressSegment`	`toHostSegment(java.lang.Integer segmentPrefixLength)` used by getHostSection, see `IPAddress.getHostSection(int)`
`abstract IPAddressSegment`	`toMaskedSegment(IPAddressSegment maskSegment, java.lang.Integer segmentPrefixLength)` returns a new segment masked by the given mask This method applies the mask first to every address in the range, and it does not preserve any existing prefix.
`IPAddressSegment`	`toNetworkSegment(java.lang.Integer segmentPrefixLength)` used by constructors of IPAddressSection, see `IPAddress.getNetworkSection(int, boolean)`
`abstract IPAddressSegment`	`toNetworkSegment(java.lang.Integer segmentPrefixLength, boolean withPrefixLength)` used by getNetworkSection and by constructors of IPAddressSection, see `IPAddress.getNetworkSection(int, boolean)`
`java.lang.String`	`toNormalizedString()` Produces a string that is somewhat similar for all address components of the same type.
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions options)`

Methods inherited from class inet.ipaddr.format.IPAddressDivision
getConfiguredString, getDivisionPrefixLength, getMaskPrefixLength, getString, getWildcardString, isBitwiseOrCompatibleWithRange, isMaskCompatibleWithRange, isPrefixed, isRangeEquivalent, isRangeEquivalentToPrefix, isRangeUnchanged, isSamePrefixedRange, matchesWithPrefix

Methods inherited from class inet.ipaddr.format.AddressDivision
compareTo, getCount, getDigitCount, getMaxDigitCount, hasUppercaseVariations, isZero, matches, matchesWithMask

Methods inherited from class inet.ipaddr.format.AddressDivisionBase
getBytes, getBytes, getDefaultTextualRadix, getDigitCount, getMaxDigitCount, getPrefixAdjustedString, getStandardString, getUpperBytes, getUpperBytes, toString

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

Methods inherited from interface inet.ipaddr.AddressSegment
equals, getMaxSegmentValue

Methods inherited from interface inet.ipaddr.AddressComponent
getByteCount

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

Methods inherited from interface java.lang.Comparable
compareTo

- Method Detail
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - getIPVersion
```
public abstract IPAddress.IPVersion getIPVersion()
```
  - getMinPrefix
```
public int getMinPrefix()
```
  - getMaxSegmentValue
```
public static int getMaxSegmentValue(IPAddress.IPVersion version)
```
  - toNetworkSegment
```
public IPAddressSegment toNetworkSegment(java.lang.Integer segmentPrefixLength)
```
    used by constructors of IPAddressSection, see IPAddress.getNetworkSection(int, boolean)
  - toNetworkSegment
```
public abstract IPAddressSegment toNetworkSegment(java.lang.Integer segmentPrefixLength,
                                                  boolean withPrefixLength)
```
    used by getNetworkSection and by constructors of IPAddressSection, see IPAddress.getNetworkSection(int, boolean)
  - toHostSegment
```
public abstract IPAddressSegment toHostSegment(java.lang.Integer segmentPrefixLength)
```
    used by getHostSection, see IPAddress.getHostSection(int)
  - toMaskedSegment
```
public abstract IPAddressSegment toMaskedSegment(IPAddressSegment maskSegment,
                                                 java.lang.Integer segmentPrefixLength)
                                          throws AddressTypeException
```
    returns a new segment masked by the given mask This method applies the mask first to every address in the range, and it does not preserve any existing prefix. The given prefix will be applied to the range of addresses after the mask. If the combination of the two does not result in a contiguous range, then AddressTypeException is thrown. See IPAddress.applyPrefixLength(int), IPAddress#apply(IPAddress, Integer), IPAddress#isMaskCompatibleWithRange(IPAddress, Integer)
    
    Throws:
    
    AddressTypeException
  - isMaskCompatibleWithRange
```
public boolean isMaskCompatibleWithRange(IPAddressSegment maskSegment,
                                         java.lang.Integer segmentPrefixLength)
```
    Check that the range resulting from the mask is contiguous, otherwise we cannot represent it. For instance, for the range 0 to 3 (bits are 00 to 11), if we mask all 4 numbers from 0 to 3 with 2 (ie bits are 10), then we are left with 1 and 3. 2 is not included. So we cannot represent 1 and 3 as a contiguous range. The underlying rule is that mask bits that are 0 must be above the resulting range in each segment. Any bit in the mask that is 0 must not fall below any bit in the masked segment range that is different between low and high. Any network mask must eliminate the entire segment range. Any host mask is fine.
    
    Parameters:
    
    maskSegment -
    
    segmentPrefixLength -
    
    Returns:
  - isMaskCompatibleWithRange
```
public boolean isMaskCompatibleWithRange(int maskValue,
                                         java.lang.Integer segmentPrefix)
```
  - getLower
```
public abstract IPAddressSegment getLower()
```
    If this segment represents a range of values, returns a segment representing just the lowest value in the range, otherwise returns this.
    
    Specified by:
    
    getLower in interface AddressComponent
    
    Specified by:
    
    getLower in interface AddressSegment
    
    Returns:
  - getUpper
```
public abstract IPAddressSegment getUpper()
```
    If this segment represents a range of values, returns a segment representing just the highest value in the range, otherwise returns this.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSegment
    
    Returns:
  - getIterable
```
public abstract java.lang.Iterable<? extends IPAddressSegment> 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 AddressSegment
    
    Returns:
  - iterator
```
public abstract java.util.Iterator<? extends IPAddressSegment> iterator()
```
    Description copied from interface: AddressComponent
    
    An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values. Call AddressItem.isMultiple() to determine if this instance represents multiple. This method iterates through the individual elements.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSegment
    
    Returns:
  - getBitCount
```
public static int getBitCount(IPAddress.IPVersion version)
```
  - getByteCount
```
public static int getByteCount(IPAddress.IPVersion version)
```
  - getDefaultTextualRadix
```
public static int getDefaultTextualRadix(IPAddress.IPVersion version)
```
  - matches
```
public boolean matches(int value)
```
    Specified by:
    
    matches in interface AddressSegment
  - matchesWithPrefix
```
public boolean matchesWithPrefix(int value,
                                 java.lang.Integer segmentPrefixLength)
```
  - matchesWithMask
```
public boolean matchesWithMask(int value,
                               int mask)
```
    Specified by:
    
    matchesWithMask in interface AddressSegment
  - getValueCount
```
public int getValueCount()
```
    Specified by:
    
    getValueCount in interface AddressSegment
    
    Returns:
    
    the same value as AddressItem.getCount()
  - getDivisionValueCount
```
public long getDivisionValueCount()
```
    Overrides:
    
    getDivisionValueCount in class AddressDivision
  - getMaxValue
```
public long getMaxValue()
```
    Overrides:
    
    getMaxValue in class AddressDivision
  - isMultiple
```
public boolean isMultiple()
```
    Description copied from interface: AddressItem
    
    Whether this represents multiple potential values (eg a prefixed address or a segment representing a range of values)
    
    Specified by:
    
    isMultiple in interface AddressItem
    
    Overrides:
    
    isMultiple in class AddressDivision
    
    Returns:
    
    whether this segment represents multiple values
  - getLowerSegmentValue
```
public int getLowerSegmentValue()
```
    returns the lower value
    
    Specified by:
    
    getLowerSegmentValue in interface AddressSegment
  - getUpperSegmentValue
```
public int getUpperSegmentValue()
```
    returns the upper value
    
    Specified by:
    
    getUpperSegmentValue in interface AddressSegment
  - getLowerValue
```
public long getLowerValue()
```
    returns the lower value as a long, although for individual segments getLowerSegmentValue() provides the same value as an int
    
    Specified by:
    
    getLowerValue in class AddressDivision
  - getUpperValue
```
public long getUpperValue()
```
    returns the lower upper value as a long, although for individual segments getUpperSegmentValue() provides the same value as an int
    
    Specified by:
    
    getUpperValue in class AddressDivision
  - reverseBits
```
public abstract IPAddressSegment reverseBits(boolean perByte)
```
    Description copied from interface: AddressComponent
    
    Returns a new AddressComponent with the bits reversed. If this component represents a range of values that cannot be reversed, then this throws AddressTypeException. In a range the most significant bits stay constant while the least significant bits range over different values, so reversing that scenario results in a series of non-consecutive values, in most cases, which cannot be represented with a single AddressComponent object. In such cases where isMultiple() is true, call iterator(), getLower(), getUpper() or some other methods to break the series down into a series representing a single value.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSegment
    
    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 abstract IPAddressSegment reverseBytes()
```
    Description copied from interface: AddressComponent
    
    Returns an AddressComponent with the bytes reversed. If this component represents a range of values that cannot be reversed, then this throws AddressTypeException. In a range the most significant bits stay constant while the least significant bits range over different values, so reversing that scenario results in a series of non-consecutive values, in most cases, which cannot be represented with a single AddressComponent object. In such cases where isMultiple() is true, call iterator(), getLower(), getUpper() or some other methods to break the series down into a series representing a single value.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Specified by:
    
    reverseBytes in interface AddressSegment
    
    Returns:
  - removePrefixLength
```
public abstract IPAddressSegment removePrefixLength()
```
  - removePrefixLength
```
public abstract IPAddressSegment removePrefixLength(boolean zeroed)
```
  - isBoundedBy
```
public boolean isBoundedBy(int value)
```
    Description copied from class: AddressDivision
    
    Returns true if the possible values of this division fall below the given value.
    
    Specified by:
    
    isBoundedBy in interface AddressStringDivision
    
    Overrides:
    
    isBoundedBy in class AddressDivision
  - getSegmentPrefixLength
```
public java.lang.Integer getSegmentPrefixLength()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - contains
```
public boolean contains(AddressSegment other)
```
    Specified by:
    
    contains in interface AddressSegment
    
    Parameters:
    
    other -
    
    Returns:
    
    whether this subnet segment contains the given address segment
  - isFullRange
```
public static boolean isFullRange(int lower,
                                  int upper,
                                  java.lang.Integer prefix,
                                  IPAddress.IPVersion version)
```
  - isFullRange
```
public static boolean isFullRange(int lower,
                                  int upper,
                                  IPAddress.IPVersion version)
```
  - isFullRange
```
public boolean isFullRange()
```
    Specified by:
    
    isFullRange in interface AddressItem
    
    Overrides:
    
    isFullRange in class AddressDivision
    
    Returns:
    
    whether this address item represents all possible values attainable by an address item of this type.
  - toHexString
```
public java.lang.String toHexString(boolean with0xPrefix)
```
    Description copied from interface: AddressComponent
    
    Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public java.lang.String toNormalizedString()
```
    Description copied from interface: AddressComponent
    
    Produces a string that is somewhat similar for all address components of the same type.
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions options)
```

Fields inherited from class inet.ipaddr.format.IPAddressDivision

Methods inherited from class inet.ipaddr.format.IPAddressDivision

Methods inherited from class inet.ipaddr.format.AddressDivision

Methods inherited from class inet.ipaddr.format.AddressDivisionBase

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.AddressSegment

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressItem

Methods inherited from interface java.lang.Comparable

isIPv4

isIPv6

getIPVersion

getMinPrefix

getMaxSegmentValue

toNetworkSegment

toNetworkSegment

toHostSegment

toMaskedSegment

isMaskCompatibleWithRange

isMaskCompatibleWithRange

getLower

getUpper

getIterable

iterator

getBitCount

getByteCount

getDefaultTextualRadix

matches

matchesWithPrefix

matchesWithMask

getValueCount

getDivisionValueCount

getMaxValue

isMultiple

getLowerSegmentValue

getUpperSegmentValue

getLowerValue

getUpperValue

reverseBits

reverseBytes

removePrefixLength

removePrefixLength

isBoundedBy

getSegmentPrefixLength

hashCode

contains

isFullRange

isFullRange

isFullRange

toHexString

toNormalizedString

toNormalizedString