ReversedType (apache-cassandra API)
Date: 2014-10-21

org.apache.cassandra.db.marshal

## Class ReversedType<T>

- java.lang.Object
- - org.apache.cassandra.db.marshal.AbstractType<T>
  - - org.apache.cassandra.db.marshal.ReversedType<T>

- All Implemented Interfaces:
    java.util.Comparator<java.nio.ByteBuffer>

      public class ReversedType<T>
      extends AbstractType<T>

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `AbstractType<T>` | `baseType`

    - ### Fields inherited from class org.apache.cassandra.db.marshal.AbstractType

      `reverseComparator`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `CQL3Type` | `asCQL3Type()`
    `int` | `compare(java.nio.ByteBuffer o1, java.nio.ByteBuffer o2)`
    `java.nio.ByteBuffer` | `fromString(java.lang.String source)` get a byte representation of the given string.
    `static <T> ReversedType<T>` | `getInstance(AbstractType<T> baseType)`
    `static <T> ReversedType<T>` | `getInstance(TypeParser parser)`
    `TypeSerializer<T>` | `getSerializer()`
    `java.lang.String` | `getString(java.nio.ByteBuffer bytes)` get a string representation of the bytes suitable for log messages
    `boolean` | `isCompatibleWith(AbstractType<?> otherType)` Returns true if this comparator is compatible with the provided previous comparator, that is if previous can safely be replaced by this.
    `boolean` | `isValueCompatibleWith(AbstractType<?> otherType)` Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType.
    `java.lang.String` | `toString()` This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).

    - ### Methods inherited from class org.apache.cassandra.db.marshal.AbstractType

      `compareCollectionMembers, componentsCount, compose, decompose, fromStringCQL2, getComponents, getString, isByteOrderComparable, isCollection, isCounter, isValueCompatibleWithInternal, parseDefaultParameters, validate, validateCellValue, validateCollectionMember`

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

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

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

      `equals`

- - ### Field Detail

    - #### baseType

          public final AbstractType<T> baseType

  - ### Method Detail

    - #### getInstance

          public static <T> ReversedType<T> getInstance(TypeParser parser)
                                             throws ConfigurationException,
                                                    SyntaxException

      Throws:
        `ConfigurationException`
        `SyntaxException`

    - #### getInstance

          public static <T> ReversedType<T> getInstance(AbstractType<T> baseType)

    - #### compare

          public int compare(java.nio.ByteBuffer o1,
                    java.nio.ByteBuffer o2)

    - #### getString

          public java.lang.String getString(java.nio.ByteBuffer bytes)

      Description copied from class: `AbstractType`
      get a string representation of the bytes suitable for log messages
      Overrides:
        `getString` in class `AbstractType<T>`

    - #### fromString

          public java.nio.ByteBuffer fromString(java.lang.String source)

      Description copied from class: `AbstractType`
      get a byte representation of the given string.
      Specified by:
        `fromString` in class `AbstractType<T>`

    - #### isCompatibleWith

          public boolean isCompatibleWith(AbstractType<?> otherType)

      Description copied from class: `AbstractType`
      Returns true if this comparator is compatible with the provided previous comparator, that is if previous can safely be replaced by this. A comparator cn should be compatible with a previous one cp if forall columns c1 and c2, if cn.validate(c1) and cn.validate(c2) and cn.compare(c1, c2) == v, then cp.validate(c1) and cp.validate(c2) and cp.compare(c1, c2) == v. Note that a type should be compatible with at least itself and when in doubt, keep the default behavior of not being compatible with any other comparator!
      Overrides:
        `isCompatibleWith` in class `AbstractType<T>`

    - #### isValueCompatibleWith

          public boolean isValueCompatibleWith(AbstractType<?> otherType)

      Description copied from class: `AbstractType`
      Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType. Note that this is a weaker version of isCompatibleWith, as it does not require that both type compare values the same way. The restriction on the other type being "reasonably" interpreted is to prevent, for example, IntegerType from being compatible with all other types. Even though any byte string is a valid IntegerType value, it doesn't necessarily make sense to interpret a UUID or a UTF8 string as an integer. Note that a type should be compatible with at least itself.
      Overrides:
        `isValueCompatibleWith` in class `AbstractType<T>`

    - #### asCQL3Type

          public CQL3Type asCQL3Type()

      Overrides:
        `asCQL3Type` in class `AbstractType<T>`

    - #### getSerializer

          public TypeSerializer<T> getSerializer()

      Specified by:
        `getSerializer` in class `AbstractType<T>`

    - #### toString

          public java.lang.String toString()

      Description copied from class: `AbstractType`
      This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()). Note that for backwards compatibility this includes the full classname. For CQL purposes the short name is fine.
      Overrides:
        `toString` in class `AbstractType<T>`

Copyright © 2014 The Apache Software Foundation