org.apache.cassandra.dht

## Class Range<T extends RingPosition<T>>

- java.lang.Object
- - org.apache.cassandra.dht.AbstractBounds<T>
  - - org.apache.cassandra.dht.Range<T>

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Range<T>>
  Direct Known Subclasses:
    MerkleTree.TreeRange

      public class Range<T extends RingPosition<T>>
      extends AbstractBounds<T>
      implements java.lang.Comparable<Range<T>>, java.io.Serializable

  A representation of the range that a node is responsible for on the DHT ring. A Range is responsible for the tokens between (left, right]. Used by the partitioner and by map/reduce by-token range scans. Note: this class has a natural ordering that is inconsistent with equals
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Range.OrderedRangeContainmentChecker` Helper class to check if a token is contained within a given collection of ranges

    - ### Nested classes/interfaces inherited from class org.apache.cassandra.dht.AbstractBounds

      `AbstractBounds.AbstractBoundsSerializer<T extends RingPosition<T>>, AbstractBounds.Boundary<T extends RingPosition<T>>`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static long` | `serialVersionUID`

    - ### Fields inherited from class org.apache.cassandra.dht.AbstractBounds

      `left, right, rowPositionSerializer, tokenSerializer`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Range(T left, T right)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.List<java.lang.String>` | `asList()`
    `int` | `compareTo(Range<T> rhs)` Note: this class has a natural ordering that is inconsistent with equals
    `boolean` | `contains(Range<T> that)`
    `boolean` | `contains(T point)` Helps determine if a given point on the DHT ring is contained in the range in question.
    `static <T extends RingPosition<T>> boolean` | `contains(T left, T right, T point)`
    `java.util.Set<Range<T>>` | `differenceToFetch(Range<T> rhs)` Calculate set of the difference ranges of given two ranges (as current (A, B] and rhs is (C, D]) which node will need to fetch when moving to a given new token
    `boolean` | `equals(java.lang.Object o)`
    `protected java.lang.String` | `getClosingString()`
    `protected java.lang.String` | `getOpeningString()`
    `boolean` | `inclusiveLeft()`
    `boolean` | `inclusiveRight()`
    `java.util.Set<Range<T>>` | `intersectionWith(Range<T> that)`
    `boolean` | `intersects(AbstractBounds<T> that)`
    `boolean` | `intersects(Bounds<T> that)`
    `boolean` | `intersects(Range<T> that)`
    `boolean` | `isEndInclusive()`
    `static <T extends RingPosition<T>> boolean` | `isInRanges(T token, java.lang.Iterable<Range<T>> ranges)`
    `boolean` | `isStartInclusive()`
    `boolean` | `isWrapAround()`
    `static <T extends RingPosition<T>> boolean` | `isWrapAround(T left, T right)` Tells if the given range is a wrap around.
    `static Range<PartitionPosition>` | `makeRowRange(Range<Token> tokenBounds)`
    `static Range<PartitionPosition>` | `makeRowRange(Token left, Token right)` Compute a range of keys corresponding to a given range of token.
    `static <T extends RingPosition<T>> java.util.List<Range<T>>` | `normalize(java.util.Collection<Range<T>> ranges)`
    `static <T extends RingPosition<T>> java.util.Set<Range<T>>` | `rangeSet(Range<T>... ranges)`
    `static <T extends RingPosition<T>> java.util.Set<Range<T>>` | `rangeSet(Range<T> range)`
    `static <T extends RingPosition<T>> java.util.List<Range<T>>` | `sort(java.util.Collection<Range<T>> ranges)`
    `Pair<AbstractBounds<T>,AbstractBounds<T>>` | `split(T position)` Given token T and AbstractBounds ?L,R?, returns Pair(?L,T], (T,R?), where ? means that the same type of AbstractBounds is returned as the original.
    `java.util.Set<Range<T>>` | `subtract(Range<T> rhs)`
    `java.util.Set<Range<T>>` | `subtractAll(java.util.Collection<Range<T>> ranges)`
    `java.lang.String` | `toString()`
    `java.util.List<Range<T>>` | `unwrap()`
    `AbstractBounds<T>` | `withNewRight(T newRight)`

    - ### Methods inherited from class org.apache.cassandra.dht.AbstractBounds

      `bounds, bounds, getString, hashCode, intersects, isEmpty, leftBoundary, maxLeft, maxLeft, minRight, minRight, noneStrictlyWrapsAround, rightBoundary, strictlyWrapsAround`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### serialVersionUID

          public static final long serialVersionUID

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Range

          public Range(T left,
                       T right)

  - ### Method Detail

    - #### contains

          public static <T extends RingPosition<T>> boolean contains(T left,
                                                                     T right,
                                                                     T point)

    - #### contains

          public boolean contains(Range<T> that)

    - #### contains

          public boolean contains(T point)

      Helps determine if a given point on the DHT ring is contained in the range in question.
      Specified by:
        `contains` in class `AbstractBounds<T extends RingPosition<T>>`
      Parameters:
        `point` - point in question
      Returns:
        true if the point contains within the range else false.

    - #### intersects

          public boolean intersects(Range<T> that)

      Parameters:
        `that` - range to check for intersection
      Returns:
        true if the given range intersects with this range.

    - #### intersects

          public boolean intersects(AbstractBounds<T> that)

    - #### intersects

          public boolean intersects(Bounds<T> that)

      Parameters:
        `that` - range to check for intersection
      Returns:
        true if the given range intersects with this range.

    - #### rangeSet

          @SafeVarargs
          public static <T extends RingPosition<T>> java.util.Set<Range<T>> rangeSet(Range<T>... ranges)

    - #### rangeSet

          public static <T extends RingPosition<T>> java.util.Set<Range<T>> rangeSet(Range<T> range)

    - #### intersectionWith

          public java.util.Set<Range<T>> intersectionWith(Range<T> that)

      Parameters:
        `that` -
      Returns:
        the intersection of the two Ranges. this can be two disjoint Ranges if one is wrapping and one is not. say you have nodes G and M, with query range (D,T]; the intersection is (M-T] and (D-G]. If there is no intersection, an empty list is returned.

    - #### split

          public Pair<AbstractBounds<T>,AbstractBounds<T>> split(T position)

      Description copied from class: `AbstractBounds`
      Given token T and AbstractBounds ?L,R?, returns Pair(?L,T], (T,R?), where ? means that the same type of AbstractBounds is returned as the original. Put another way, returns a Pair of everything this AbstractBounds contains up to and including the split position, and everything it contains after (not including the split position). The original AbstractBounds must either contain the position T, or T should be equals to the left bound L. If the split would only yield the same AbstractBound, null is returned instead.
      Specified by:
        `split` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### inclusiveLeft

          public boolean inclusiveLeft()

      Specified by:
        `inclusiveLeft` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### inclusiveRight

          public boolean inclusiveRight()

      Specified by:
        `inclusiveRight` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### unwrap

          public java.util.List<Range<T>> unwrap()

      Specified by:
        `unwrap` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### isWrapAround

          public static <T extends RingPosition<T>> boolean isWrapAround(T left,
                                                                         T right)

      Tells if the given range is a wrap around.

    - #### compareTo

          public int compareTo(Range<T> rhs)

      Note: this class has a natural ordering that is inconsistent with equals
      Specified by:
        `compareTo` in interface `java.lang.Comparable<Range<T extends RingPosition<T>>>`

    - #### subtract

          public java.util.Set<Range<T>> subtract(Range<T> rhs)

    - #### subtractAll

          public java.util.Set<Range<T>> subtractAll(java.util.Collection<Range<T>> ranges)

    - #### differenceToFetch

          public java.util.Set<Range<T>> differenceToFetch(Range<T> rhs)

      Calculate set of the difference ranges of given two ranges (as current (A, B] and rhs is (C, D]) which node will need to fetch when moving to a given new token
      Parameters:
        `rhs` - range to calculate difference
      Returns:
        set of difference ranges

    - #### isInRanges

          public static <T extends RingPosition<T>> boolean isInRanges(T token,
                                                                       java.lang.Iterable<Range<T>> ranges)

    - #### equals

          public boolean equals(java.lang.Object o)

      Overrides:
        `equals` in class `java.lang.Object`

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.Object`

    - #### getOpeningString

          protected java.lang.String getOpeningString()

      Specified by:
        `getOpeningString` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### getClosingString

          protected java.lang.String getClosingString()

      Specified by:
        `getClosingString` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### isStartInclusive

          public boolean isStartInclusive()

      Specified by:
        `isStartInclusive` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### isEndInclusive

          public boolean isEndInclusive()

      Specified by:
        `isEndInclusive` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### asList

          public java.util.List<java.lang.String> asList()

    - #### isWrapAround

          public boolean isWrapAround()

    - #### normalize

          public static <T extends RingPosition<T>> java.util.List<Range<T>> normalize(java.util.Collection<Range<T>> ranges)

      Returns:
        A copy of the given list of with all ranges unwrapped, sorted by left bound and with overlapping bounds merged.

    - #### withNewRight

          public AbstractBounds<T> withNewRight(T newRight)

      Specified by:
        `withNewRight` in class `AbstractBounds<T extends RingPosition<T>>`

    - #### sort

          public static <T extends RingPosition<T>> java.util.List<Range<T>> sort(java.util.Collection<Range<T>> ranges)

    - #### makeRowRange

          public static Range<PartitionPosition> makeRowRange(Token left,
                                                              Token right)

      Compute a range of keys corresponding to a given range of token.

    - #### makeRowRange

          public static Range<PartitionPosition> makeRowRange(Range<Token> tokenBounds)

Copyright © 2018 The Apache Software Foundation