Module uk.ipfreely
Package uk.ipfreely.sets

Interface Range<A extends Addr<A>>

Type Parameters:
A - address type
All Superinterfaces:
AddressSet<A>, Iterable<A>
All Known Subinterfaces:
Block<A>
public interface Range<A extends Addr<A>> extends AddressSet<A>

AddressSet interface that forms contiguous range of one or more Addresses.

See AddressSet for implementation contract.

Implementations are always contiguous lists.

  • Method Details

    • first

      A first()
      Least element in the range.
      Returns:
      first

    • last

      A last()
      Greatest element in the range.
      Returns:
      last

    • family

      default Family<A> family()
      Convenience method.
      Returns:
      range family

    • ranges

      default Stream<Range<A>> ranges()
      Description copied from interface: AddressSet

      Constituent Ranges.

      Adjacent or overlapping ranges MUST be combined into a single Range. Elements MUST be produced from least Address to greatest.

      A Stream of Address values can be obtained with ranges().flatMap(Range::stream). A Stream of Blocks can be obtained with ranges().flatMap(Range::blocks).

      Specified by:
      ranges in interface AddressSet<A extends Addr<A>>
      Returns:
      constituent ranges

    • size

      default BigInteger size()
      Number of Addres in range.
      Specified by:
      size in interface AddressSet<A extends Addr<A>>
      Returns:
      number of addresses including first() and last()

    • isEmpty

      default boolean isEmpty()
      Range is never empty.
      Specified by:
      isEmpty in interface AddressSet<A extends Addr<A>>
      Returns:
      false

    • contains

      default boolean contains(Addr<?> address)
      Tests argument is same Family and more than or equal to first() and less than or equal to last().
      Specified by:
      contains in interface AddressSet<A extends Addr<A>>
      Parameters:
      address - candidate (cannot be null)
      Returns:
      true if this sequence contains the given IP address

    • iterator

      default Iterator<A> iterator()
      All addresses in the range.
      Specified by:
      iterator in interface Iterable<A extends Addr<A>>
      Returns:
      from first to last

    • spliterator

      default Spliterator<A> spliterator()

      Default Spliterator.characteristics(): Spliterator.IMMUTABLE; Spliterator.DISTINCT; Spliterator.ORDERED; Spliterator.SORTED; Spliterator.NONNULL. If smaller than Long.MAX_VALUE also Spliterator.SIZED and Spliterator.SUBSIZED.

      Spliterator.trySplit() is implemented.

      Specified by:
      spliterator in interface AddressSet<A extends Addr<A>>
      Specified by:
      spliterator in interface Iterable<A extends Addr<A>>
      Returns:
      all addresses in set

    • stream

      default Stream<A> stream()
      All addresses in the range.
      Returns:
      from first to last

    • blocks

      default Stream<Block<A>> blocks()
      Streams arbitrary range as valid CIDR blocks.
      Returns:
      stream

    • contiguous

      default boolean contiguous(Range<A> r)
      Tests if this range can create a contiguous range with another. That is, either intersects(Range) or adjacent(Range) are true.
      Parameters:
      r - another range
      Returns:
      true if contiguous

    • intersects

      default boolean intersects(Range<A> r)
      Tests if there is any overlap in the address ranges.
      Parameters:
      r - another range
      Returns:
      true on intersection

    • adjacent

      default boolean adjacent(Range<A> r)
      Tests if the last value in either range is one less than the first value of the other.
      Parameters:
      r - another range
      Returns:
      true if adjacent

    • extremes

      default Range<A> extremes(Range<A> other)
      Combines two ranges into a single range using the least and greatest values from each. The ranges do NOT have to be contiguous - this is not a union method.
      Parameters:
      other - another range
      Returns:
      new range
      See Also: