org.apache.cassandra.db.filter

## Class ColumnSlice

- java.lang.Object
- - org.apache.cassandra.db.filter.ColumnSlice

-     public class ColumnSlice
      extends java.lang.Object

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ColumnSlice.Serializer`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static ColumnSlice` | `ALL_COLUMNS`
    `static ColumnSlice[]` | `ALL_COLUMNS_ARRAY`
    `Composite` | `finish`
    `Composite` | `start`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ColumnSlice(Composite start, Composite finish)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static ColumnSlice[]` | `deoverlapSlices(ColumnSlice[] slices, java.util.Comparator<Composite> comparator)` Takes an array of slices (potentially overlapping and in any order, though each individual slice must have its start before or equal its end in `comparator` orde) and return an equivalent array of non-overlapping slices in `comparator order`.
    `boolean` | `equals(java.lang.Object o)`
    `int` | `hashCode()`
    `boolean` | `includes(java.util.Comparator<Composite> cmp, Composite name)`
    `boolean` | `intersects(java.util.List<java.nio.ByteBuffer> minCellNames, java.util.List<java.nio.ByteBuffer> maxCellNames, CellNameType comparator, boolean reversed)`
    `boolean` | `isAlwaysEmpty(CellNameType comparator, boolean reversed)`
    `boolean` | `isBefore(java.util.Comparator<Composite> cmp, Composite name)`
    `java.lang.String` | `toString()`
    `static boolean` | `validateSlices(ColumnSlice[] slices, CellNameType type, boolean reversed)` Validates that the provided slice array contains only non-overlapped slices valid for a query `reversed` or not on a table using `comparator`.

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

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

- - ### Field Detail

    - #### ALL_COLUMNS

          public static final ColumnSlice ALL_COLUMNS

    - #### ALL_COLUMNS_ARRAY

          public static final ColumnSlice[] ALL_COLUMNS_ARRAY

    - #### start

          public final Composite start

    - #### finish

          public final Composite finish

  - ### Constructor Detail

    - #### ColumnSlice

          public ColumnSlice(Composite start,
                             Composite finish)

  - ### Method Detail

    - #### isAlwaysEmpty

          public boolean isAlwaysEmpty(CellNameType comparator,
                                       boolean reversed)

    - #### includes

          public boolean includes(java.util.Comparator<Composite> cmp,
                                  Composite name)

    - #### isBefore

          public boolean isBefore(java.util.Comparator<Composite> cmp,
                                  Composite name)

    - #### intersects

          public boolean intersects(java.util.List<java.nio.ByteBuffer> minCellNames,
                                    java.util.List<java.nio.ByteBuffer> maxCellNames,
                                    CellNameType comparator,
                                    boolean reversed)

    - #### validateSlices

          public static boolean validateSlices(ColumnSlice[] slices,
                                               CellNameType type,
                                               boolean reversed)

      Validates that the provided slice array contains only non-overlapped slices valid for a query `reversed` or not on a table using `comparator`.

    - #### deoverlapSlices

          public static ColumnSlice[] deoverlapSlices(ColumnSlice[] slices,
                                                      java.util.Comparator<Composite> comparator)

      Takes an array of slices (potentially overlapping and in any order, though each individual slice must have its start before or equal its end in `comparator` orde) and return an equivalent array of non-overlapping slices in `comparator order`.
      Parameters:
        `slices` - an array of slices. This may be modified by this method.
        `comparator` - the order in which to sort the slices.
      Returns:
        the smallest possible array of non-overlapping slices in `compator` order. If the original slices are already non-overlapping and in comparator order, this may or may not return the provided slices directly.

    - #### hashCode

          public final int hashCode()

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

    - #### equals

          public final 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`

Copyright © 2018 The Apache Software Foundation