org.apache.cassandra.db

## Class ClusteringComparator

- java.lang.Object
- - org.apache.cassandra.db.ClusteringComparator

All Implemented Interfaces:
  java.util.Comparator<Clusterable>

    public class ClusteringComparator
    extends java.lang.Object
    implements java.util.Comparator<Clusterable>

A comparator of clustering prefixes (or more generally of `Clusterable`}.

This is essentially just a composite comparator that the clustering values of the provided clustering prefixes in lexicographical order, with each component being compared based on the type of the clustering column this is a value of.

### Constructor Summary

Constructors
Constructor and Description
`ClusteringComparator(AbstractType<?>... clusteringTypes)`
`ClusteringComparator(java.util.List<AbstractType<?>> clusteringTypes)`

### Method Summary

All Methods Instance Methods Concrete Methods
`int` `compare(Clusterable c1, Clusterable c2)`
`int` `compare(Clustering c1, Clustering c2)`
`int` `compare(Clustering c1, Clustering c2, int size)` Compares the specified part of the specified clusterings.
`int` `compare(ClusteringPrefix c1, ClusteringPrefix c2)`
`int` `compareComponent(int i, java.nio.ByteBuffer v1, java.nio.ByteBuffer v2)`
`boolean` `equals(java.lang.Object o)`
`int` `hashCode()`
`java.util.Comparator<IndexInfo>` `indexComparator(boolean reversed)`
`boolean` `isCompatibleWith(ClusteringComparator previous)` Returns whether this clustering comparator is compatible with the provided one, that is if the provided one can be safely replaced by this new one.
`Clustering` `make(java.lang.Object... values)` Creates a row clustering based on the clustering values.
`java.util.Comparator<Clusterable>` `reversed()`
`java.util.Comparator<Row>` `rowComparator()` A comparator for rows.
`int` `size()` The number of clustering columns for the table this is the comparator of.
`AbstractType<?>` `subtype(int i)` Returns the type of the ith clustering column of the table.
`java.util.List<AbstractType<?>>` `subtypes()` The "subtypes" of this clustering comparator, that is the types of the clustering columns for the table this is a comparator of.
`java.lang.String` `toString()`
`void` `validate(ClusteringPrefix clustering)` Validates the provided prefix for corrupted data.

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

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

### Methods inherited from interface java.util.Comparator

`comparing, comparing, comparingDouble, comparingInt, comparingLong, naturalOrder, nullsFirst, nullsLast, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

### Constructor Detail

#### ClusteringComparator

    public ClusteringComparator(AbstractType<?>... clusteringTypes)

#### ClusteringComparator

    public ClusteringComparator(java.util.List<AbstractType<?>> clusteringTypes)

### Method Detail

#### size

    public int size()

The number of clustering columns for the table this is the comparator of.

#### subtypes

    public java.util.List<AbstractType<?>> subtypes()

The "subtypes" of this clustering comparator, that is the types of the clustering columns for the table this is a comparator of.

#### subtype

    public AbstractType<?> subtype(int i)

Returns the type of the ith clustering column of the table.

#### make

    public Clustering make(java.lang.Object... values)

Creates a row clustering based on the clustering values.

Every argument can either be a `ByteBuffer`, in which case it is used as-is, or a object corresponding to the type of the corresponding clustering column, in which case it will be converted to a byte buffer using the column type.

Parameters:
  `values` - the values to use for the created clustering. There should be exactly `size()` values which must be either byte buffers or of the type the column expect.
Returns:
  the newly created clustering.

#### compare

    public int compare(Clusterable c1,
                       Clusterable c2)

Specified by:
  `compare` in interface `java.util.Comparator<Clusterable>`

#### compare

    public int compare(ClusteringPrefix c1,
                       ClusteringPrefix c2)

#### compare

    public int compare(Clustering c1,
                       Clustering c2)

#### compare

    public int compare(Clustering c1,
                       Clustering c2,
                       int size)

Compares the specified part of the specified clusterings.

Parameters:
  `c1` - the first clustering
  `c2` - the second clustering
  `size` - the number of components to compare
Returns:
  a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

#### compareComponent

    public int compareComponent(int i,
                                java.nio.ByteBuffer v1,
                                java.nio.ByteBuffer v2)

#### isCompatibleWith

    public boolean isCompatibleWith(ClusteringComparator previous)

Returns whether this clustering comparator is compatible with the provided one, that is if the provided one can be safely replaced by this new one.

Parameters:
  `previous` - the previous comparator that we want to replace and test compatibility with.
Returns:
  whether `previous` can be safely replaced by this comparator.

#### validate

    public void validate(ClusteringPrefix clustering)

Validates the provided prefix for corrupted data.

Parameters:
  `clustering` - the clustering prefix to validate.
Throws:
  `MarshalException` - if `clustering` contains some invalid data.

#### rowComparator

    public java.util.Comparator<Row> rowComparator()

A comparator for rows. A `Row` is a `Clusterable` so `ClusteringComparator` can be used to compare rows directly, but when we know we deal with rows (and not `Clusterable` in general), this is a little faster because by knowing we compare `Clustering` objects, we know that 1) they all have the same size and 2) they all have the same kind.

#### indexComparator

    public java.util.Comparator<IndexInfo> indexComparator(boolean reversed)

#### reversed

    public java.util.Comparator<Clusterable> reversed()

Specified by:
  `reversed` in interface `java.util.Comparator<Clusterable>`

#### toString

    public java.lang.String toString()

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

#### equals

    public boolean equals(java.lang.Object o)

Specified by:
  `equals` in interface `java.util.Comparator<Clusterable>`
Overrides:
  `equals` in class `java.lang.Object`

#### hashCode

    public int hashCode()

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