Module inet.ipaddr
Package inet.ipaddr

Interface AddressSegment

All Superinterfaces:
AddressComponent, AddressComponentRange, AddressGenericDivision, AddressItem, AddressItemRange, AddressStringDivision, Comparable<AddressItem>, Serializable
All Known Implementing Classes:
IPAddressSegment, IPv4AddressSegment, IPv6AddressSegment, MACAddressSegment

public interface AddressSegment extends AddressComponent, AddressGenericDivision
Represents a single segment of an address.

The current implementations of this class are the most common representations of IPv4, IPv6 and MAC; segments are 1 byte for Ipv4, they are two bytes for Ipv6, and they are 1 byte for MAC addresses.

There are alternative forms of dividing addresses into segments, such as dotted representation for MAC like 1111.2222.3333, embedded IPv4 representation for IPv6 like f:f:f:f:f:f:1.2.3.4, inet_aton formats like 1.2 for IPv4, and so on.

If those alternative representations were to follow the general rules for segment representation, then you could reuse this class for thos alternative representations.

The general rules are that segments have a whole number of bytes, and in a given address all segments have the same length.

When alternatives forms do not follow the general rules for segments, you can use the AddressDivision interface instead. Divisions do not have the restriction that divisions of an address are equal length and a whole number of bytes. Divisions can be grouped using AddressDivisionGrouping.

AddressSegment objects are immutable and thus also thread-safe.

Author:
sfoley
  • Method Details

    • getValueCount

      int getValueCount()
      Returns:
      the same value as AddressItem.getCount() as an integer
    • getSegmentValue

      int getSegmentValue()
      returns the lower value
    • getUpperSegmentValue

      int getUpperSegmentValue()
      returns the upper value
    • getLower

      AddressSegment 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 AddressComponentRange
      Returns:
    • getUpper

      AddressSegment 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 AddressComponentRange
      Returns:
    • reverseBits

      AddressSegment 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 IncompatibleAddressException. 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
      Parameters:
      perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
      Returns:
    • reverseBytes

      AddressSegment 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 IncompatibleAddressException. 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
      Returns:
    • getIterable

      Iterable<? extends AddressSegment> 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 AddressComponentRange
      Returns:
    • iterator

      Iterator<? extends AddressSegment> 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 AddressComponentRange
      Returns:
    • 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 AddressComponentRange
      Returns:
    • stream

      Stream<? extends AddressSegment> 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 AddressComponentRange
      Returns:
    • matches

      boolean matches(int value)
    • matchesWithMask

      boolean matchesWithMask(int value, int mask)
    • matchesWithMask

      boolean matchesWithMask(int lowerValue, int upperValue, int mask)
    • contains

      boolean contains(AddressSegment other)
    • equals

      boolean equals(Object other)
      Overrides:
      equals in class Object
    • prefixEquals

      boolean prefixEquals(AddressSegment other, int prefixLength)
      Returns whether the given prefix bits match the same bits of the given segment.
      Parameters:
      other -
      prefixLength -
      Returns:
    • testBit

      default boolean testBit(int n)
      Analogous to BigInteger.testBit(int), Computes (this & (1 << n)) != 0)
      Parameters:
      n -
      Returns:
      Throws:
      IndexOutOfBoundsException - if the index is negative or as large as the bit count
      See Also:
    • isOneBit

      default boolean isOneBit(int segmentBitIndex)
      Returns true if the bit in the lower value of this segment at the given index is 1, where index 0 is the most significant bit.
      Parameters:
      segmentBitIndex -
      Returns:
      Throws:
      IndexOutOfBoundsException - if the index is negative or as large as the bit count
      See Also:
    • getMaxSegmentValue

      int getMaxSegmentValue()
      Gets the maximum possible value for this type of segment (for the highest range value of this particular segment, use getUpper()
      Returns: