## org.apache.cassandra.dht
Class Bounds<T extends RingPosition>

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

All Implemented Interfaces:
  java.io.Serializable

    public class Bounds<T extends RingPosition>

extends AbstractBounds<T>

AbstractBounds containing both its endpoints: [left, right]. Used by "classic" by-key range scans.

See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.cassandra.dht.AbstractBounds
`AbstractBounds.AbstractBoundsSerializer`

Field Summary

Fields inherited from class org.apache.cassandra.dht.AbstractBounds
`left, partitioner, right`

Constructor Summary
`Bounds(T left, T right)`

Method Summary
`boolean` `contains(T position)`
`boolean` `equals(java.lang.Object o)`
`boolean` `intersects(Bounds<T> that)`
`static Bounds<RowPosition>` `makeRowBounds(Token left, Token right, IPartitioner partitioner)` Compute a bounds of keys corresponding to a given bounds of token.
`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.
`AbstractBounds<RowPosition>` `toRowBounds()` Transform this abstract bounds to equivalent covering bounds of row positions.
`java.lang.String` `toString()`
`AbstractBounds<Token>` `toTokenBounds()` Transform this abstract bounds to a token abstract bounds.
`java.util.List<? extends AbstractBounds<T>>` `unwrap()`

Methods inherited from class org.apache.cassandra.dht.AbstractBounds
`hashCode, intersects, serializer`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### Bounds

    public Bounds(T left,
                  T right)

Method Detail

### contains

    public boolean contains(T position)

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

### 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>`

### intersects

    public boolean intersects(Bounds<T> that)

### unwrap

    public java.util.List<? extends AbstractBounds<T>> unwrap()

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

### 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`

### makeRowBounds

    public static Bounds<RowPosition> makeRowBounds(Token left,
                                                    Token right,
                                                    IPartitioner partitioner)

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

### toRowBounds

    public AbstractBounds<RowPosition> toRowBounds()

  Description copied from class: `AbstractBounds`
  Transform this abstract bounds to equivalent covering bounds of row positions. If this abstract bounds was already an abstractBounds of row positions, this is a noop.

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

### toTokenBounds

    public AbstractBounds<Token> toTokenBounds()

  Description copied from class: `AbstractBounds`
  Transform this abstract bounds to a token abstract bounds. If this abstract bounds was already an abstractBounds of token, this is a noop, otherwise this use the row position tokens.

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

Copyright © 2013 The Apache Software Foundation