AddressSegmentSeries (IPAddress javadoc by seancfoley)

All Superinterfaces:

AddressComponent, AddressDivisionSeries, AddressItem, AddressItemRange, inet.ipaddr.format.string.AddressStringDivisionSeries, java.lang.Comparable<AddressItem>, java.io.Serializable

All Known Subinterfaces:

AddressSection, IPAddressSegmentSeries

All Known Implementing Classes:

Address, IPAddress, IPAddressSection, IPv4Address, IPv4AddressSection, IPv6Address, IPv6AddressSection, MACAddress, MACAddressSection
```
public interface AddressSegmentSeries
extends AddressDivisionSeries, AddressComponent
```
Represents a series of address segments, each of equal byte size, the byte size being a whole number of bytes. Each segment can potentially range over multiple values, and thus this series of segments can represent many different values as well.

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`AddressSegmentSeries`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`AddressSegmentSeries`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`AddressSegmentSeries`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`AddressSegmentSeries`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`AddressSegmentSeries`	`applyPrefixLength(int prefixLength)` Applies the given prefix length to create a new segment series.
`int`	`getBitsPerSegment()` Returns the number of bits comprising each segment in this series.
`int`	`getBytesPerSegment()` Returns the number of bytes comprising each segment in this series.
`java.lang.Iterable<? extends AddressSegmentSeries>`	`getIterable()` Useful for using an instance in a "for-each loop".
`AddressSegmentSeries`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`int`	`getMaxSegmentValue()`
`AddressNetwork<?>`	`getNetwork()` Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`AddressSection`	`getSection()` Gets the subsection from the series that comprises all segments
`AddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`AddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`AddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`int`	`getSegmentCount()` Returns the number of segments in this series.
`AddressSegment[]`	`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(int start, int end, AddressSegment[] segs, int index)` get the segments from start to end and insert into the segs array at the the given index
`java.lang.String[]`	`getSegmentStrings()` Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
`AddressSegmentSeries`	`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.
`AddressSegmentSeries`	`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.
`AddressSegmentSeries`	`incrementBoundary(long increment)` If the given increment is positive, adds the value to the upper series (`getUpper()` in the subnet range to produce a new series.
`java.util.Iterator<? extends AddressSegmentSeries>`	`iterator()` Iterates through the individual segment series.
`java.util.Iterator<? extends AddressSegmentSeries>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`java.util.Iterator<? extends AddressSegmentSeries>`	`prefixIterator()` Iterates through the individual prefixes.
`AddressSegmentSeries`	`removePrefixLength()` Removes the prefix length while zeroing out the existing host.
`AddressSegmentSeries`	`removePrefixLength(boolean zeroed)` Deprecated. use `removePrefixLength()` or `withoutPrefixLength()`
`AddressSegmentSeries`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`AddressSegmentSeries`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`AddressSegmentSeries`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`AddressSegmentSeries`	`reverseSegments()` Returns a new segment series with the segments reversed.
`java.util.Iterator<? extends AddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`AddressSegmentSeries`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`AddressSegmentSeries`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`java.lang.String`	`toCanonicalString()` Produces the canonical representation of the address
`java.lang.String`	`toCompressedString()` Produces a short representation of the address while remaining within the confines of standard representation(s) of the address
`AddressSegmentSeries`	`toPrefixBlock()` If this series has a prefix length, returns the block for that prefix.
`AddressSegmentSeries`	`withoutPrefixLength()` Provides the same address with no prefix.

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getBitCount, getBlockCount, getCount, getDivision, getDivisionStrings, getPrefixCount, getPrefixCount, getPrefixLength, isMore, isPrefixBlock, isPrefixed, isSequential, isSinglePrefixBlock

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

Methods inherited from interface inet.ipaddr.AddressComponent
toHexString, toNormalizedString

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

- Method Detail
  - getNetwork
```
AddressNetwork<?> getNetwork()
```
    Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Returns:
  - getSegmentCount
```
int getSegmentCount()
```
    Returns the number of segments in this series.
    
    Returns:
  - getBitsPerSegment
```
int getBitsPerSegment()
```
    Returns the number of bits comprising each segment in this series. Segments in the same series are equal length.
    
    Returns:
  - getBytesPerSegment
```
int getBytesPerSegment()
```
    Returns the number of bytes comprising each segment in this series. Segments in the same series are equal length.
    
    Returns:
  - getMaxSegmentValue
```
int getMaxSegmentValue()
```
    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.
  - getSection
```
AddressSection getSection()
```
    Gets the subsection from the series that comprises all segments
    
    Returns:
  - getSection
```
AddressSection getSection(int index)
```
    Gets the subsection from the series starting from the given index
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is negative
  - getSection
```
AddressSection getSection(int index,
                          int endIndex)
```
    Gets the subsection from the series starting from the given index and ending just before the give endIndex
    
    Parameters:
    
    index -
    
    endIndex -
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is negative or endIndex extends beyond the end of the series
  - getSegment
```
AddressSegment getSegment(int index)
```
    Returns the segment from this series at the given index.
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index is negative or as large as the segment count
  - getSegmentStrings
```
java.lang.String[] getSegmentStrings()
```
    Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
    
    Returns:
  - getSegments
```
void getSegments(AddressSegment[] segs)
```
    Copies the existing segments into the given array. The array size should be at least as large as getSegmentCount()
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the provided array is too small
  - getSegments
```
void getSegments(int start,
                 int end,
                 AddressSegment[] segs,
                 int index)
```
    get the segments from start to end and insert into the segs array at the the given index
    
    Parameters:
    
    start - the first segment index from this series to be included
    
    end - the first segment index to be excluded
    
    segs - the target array
    
    index - where to insert the segments in the segs array
  - getSegments
```
AddressSegment[] getSegments()
```
    Returns the segments of this series of segments as an array. This must create a new array, so for efficiency use getSegment(int) and getSegmentCount() instead when feasible.
    
    Returns:
  - getLower
```
AddressSegmentSeries getLower()
```
    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 AddressItemRange
    
    Returns:
  - getUpper
```
AddressSegmentSeries 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.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressItemRange
    
    Returns:
  - getIterable
```
java.lang.Iterable<? extends AddressSegmentSeries> getIterable()
```
    Description copied from interface: AddressItemRange
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressItemRange.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponent
    
    Specified by:
    
    getIterable in interface AddressItemRange
    
    Returns:
  - iterator
```
java.util.Iterator<? extends AddressSegmentSeries> iterator()
```
    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 AddressItemRange
    
    Returns:
  - prefixIterator
```
java.util.Iterator<? extends AddressSegmentSeries> prefixIterator()
```
    Iterates through the individual prefixes. If the series has no prefix length, then this is equivalent to iterator()
  - prefixBlockIterator
```
java.util.Iterator<? extends AddressSegmentSeries> prefixBlockIterator()
```
    Iterates through the individual prefix blocks. If the series has no prefix length, then this is equivalent to iterator()
  - segmentsIterator
```
java.util.Iterator<? extends AddressSegment[]> segmentsIterator()
```
    Iterates through the individual segments.
  - increment
```
AddressSegmentSeries increment(long increment)
                        throws AddressValueException
```
    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 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.
    
    Parameters:
    
    increment -
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - incrementBoundary
```
AddressSegmentSeries incrementBoundary(long increment)
                                throws AddressValueException
```
    If the given increment is positive, adds the value to the upper series (getUpper() in the subnet range to produce a new series. If the given increment is negative, adds the value to the lower series (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.
    
    Parameters:
    
    increment -
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - toCanonicalString
```
java.lang.String toCanonicalString()
```
    Produces the canonical representation of the address
    
    Returns:
  - toCompressedString
```
java.lang.String toCompressedString()
```
    Produces a short representation of the address while remaining within the confines of standard representation(s) of the address
    
    Returns:
  - reverseSegments
```
AddressSegmentSeries reverseSegments()
```
    Returns a new segment series with the segments reversed. This does not throw IncompatibleAddressException since all address series can reverse their segments.
    
    Returns:
  - reverseBits
```
AddressSegmentSeries reverseBits(boolean perByte)
```
    Returns a new segment series with the bits reversed.
    
    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:
    
    Throws:
    
    IncompatibleAddressException - if reversing the bits within a single segment cannot be done because the segment represents a range, and when all values in that range are reversed, the result is not contiguous. In practice this means that to be reversible the range must include all values except possibly the largest and/or smallest.
  - reverseBytes
```
AddressSegmentSeries reverseBytes()
```
    Returns a new segment series with the bytes reversed.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if the segments have more than 1 bytes, and if reversing the bits within a single segment cannot be done because the segment represents a range that is not the entire segment range.
  - reverseBytesPerSegment
```
AddressSegmentSeries reverseBytesPerSegment()
```
    Returns a new segment series with the bytes reversed within each segment.
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if the segments have more than 1 bytes, and if reversing the bits within a single segment cannot be done because the segment represents a range that is not the entire segment range.
  - toPrefixBlock
```
AddressSegmentSeries toPrefixBlock()
```
    If this series has a prefix length, returns the block for that prefix. Otherwise, this address series is returned.
    
    Returns:
    
    the block of address series for the prefix length
  - removePrefixLength
```
AddressSegmentSeries removePrefixLength()
```
    Removes the prefix length while zeroing out the existing host.
    If the series already has a prefix length, the bits outside the prefix become zero.
    Equivalent to calling removePrefixLength(true)
    
    Returns:
  - withoutPrefixLength
```
AddressSegmentSeries withoutPrefixLength()
```
    Provides the same address with no prefix. Equivalent to calling withoutPrefixLength()
  - removePrefixLength
```
AddressSegmentSeries removePrefixLength(boolean zeroed)
```
    Deprecated. use removePrefixLength() or withoutPrefixLength()
    
    Removes the prefix length.
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - adjustPrefixBySegment
```
AddressSegmentSeries adjustPrefixBySegment(boolean nextSegment)
```
    Increases or decreases prefix length to the next segment boundary.
    Follows the same rules as 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.
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    Returns:
  - adjustPrefixBySegment
```
AddressSegmentSeries adjustPrefixBySegment(boolean nextSegment,
                                           boolean zeroed)
```
    Increases or decreases prefix length to the next segment boundary.
    
    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
```
AddressSegmentSeries adjustPrefixLength(int adjustment)
```
    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.
    
    Parameters:
    
    adjustment -
    
    Returns:
  - adjustPrefixLength
```
AddressSegmentSeries adjustPrefixLength(int adjustment,
                                        boolean zeroed)
```
    Increases or decreases prefix length by the given increment.
    
    Parameters:
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    adjustment - the increment
    
    Returns:
  - setPrefixLength
```
AddressSegmentSeries setPrefixLength(int prefixLength)
```
    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.
    
    Parameters:
    
    prefixLength -
    
    Returns:
    
    See Also:
    
    applyPrefixLength(int)
  - setPrefixLength
```
AddressSegmentSeries setPrefixLength(int prefixLength,
                                     boolean zeroed)
```
    Sets the prefix length.
    When the prefix is extended beyond the segment series boundary, it is removed.
    
    Parameters:
    
    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:
  - applyPrefixLength
```
AddressSegmentSeries applyPrefixLength(int prefixLength)
```
    Applies the given prefix length to create a new segment series.
    Similar to 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.
    
    Parameters:
    
    prefixLength -
    
    Returns:
    
    See Also:
    
    setPrefixLength(int)

Interface AddressSegmentSeries

Method Summary

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

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

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressItem

Method Detail

getNetwork

getSegmentCount

getBitsPerSegment

getBytesPerSegment

getMaxSegmentValue

getSection

getSection

getSection

getSegment

getSegmentStrings

getSegments

getSegments

getSegments

getLower

getUpper

getIterable

iterator

prefixIterator

prefixBlockIterator

segmentsIterator

increment

incrementBoundary

toCanonicalString

toCompressedString

reverseSegments

reverseBits

reverseBytes

reverseBytesPerSegment

toPrefixBlock

removePrefixLength

withoutPrefixLength

removePrefixLength

adjustPrefixBySegment

adjustPrefixBySegment

adjustPrefixLength

adjustPrefixLength

setPrefixLength

setPrefixLength

applyPrefixLength