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>, AssignmentTestable

    public class ReversedType<T>
    extends AbstractType<T>

### Nested Class Summary

### Nested classes/interfaces inherited from class org.apache.cassandra.db.marshal.AbstractType

`AbstractType.ComparisonType`

### Nested classes/interfaces inherited from interface org.apache.cassandra.cql3.AssignmentTestable

`AssignmentTestable.TestResult`

### Field Summary

Fields
`AbstractType<T>` `baseType`

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

`comparisonType, isByteOrderComparable, reverseComparator`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`CQL3Type` `asCQL3Type()`
`int` `compareCustom(java.nio.ByteBuffer o1, java.nio.ByteBuffer o2)` Implement IFF ComparisonType is CUSTOM Compares the ByteBuffer representation of two instances of this class, for types where this cannot be done by simple in-order comparison of the unsigned bytes Standard Java compare semantics
`int` `compareForCQL(java.nio.ByteBuffer v1, java.nio.ByteBuffer v2)` Same as compare except that this ignore ReversedType.
`Term` `fromJSONObject(java.lang.Object parsed)` Given a parsed JSON string, return a byte representation of the object.
`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 used for various identifier (NOT just 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` `isEmptyValueMeaningless()` Returns `true` for types where empty should be handled like `null` like `Int32Type`.
`boolean` `isReversed()`
`boolean` `isValueCompatibleWith(AbstractType<?> otherType)` Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType.
`boolean` `referencesUserType(java.lang.String userTypeName)`
`java.lang.String` `toJSONString(java.nio.ByteBuffer buffer, ProtocolVersion protocolVersion)` Converts the specified value into its JSON representation.
`java.lang.String` `toString()` This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).
`protected int` `valueLengthIfFixed()` The length of values for this type if all values are of fixed length, -1 otherwise.

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

`asCQLTypeStringList, checkComparable, compare, compareCollectionMembers, componentsCount, compose, decompose, equals, freeze, freezeNestedMulticellTypes, getComponents, getString, isCollection, isCounter, isFreezable, isFrozenCollection, isMultiCell, isTuple, isUDT, isValueCompatibleWithInternal, parseDefaultParameters, readValue, readValue, referencesDuration, skipValue, testAssignment, toString, validate, validateCellValue, validateCollectionMember, writeValue, writtenLength`

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

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

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

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

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

#### isEmptyValueMeaningless

    public boolean isEmptyValueMeaningless()

Description copied from class: `AbstractType`
Returns `true` for types where empty should be handled like `null` like `Int32Type`.

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

#### compareCustom

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

Description copied from class: `AbstractType`
Implement IFF ComparisonType is CUSTOM Compares the ByteBuffer representation of two instances of this class, for types where this cannot be done by simple in-order comparison of the unsigned bytes Standard Java compare semantics

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

#### compareForCQL

    public int compareForCQL(java.nio.ByteBuffer v1,
                             java.nio.ByteBuffer v2)

Description copied from class: `AbstractType`
Same as compare except that this ignore ReversedType. This is to be use when comparing 2 values to decide for a CQL condition (see Operator.isSatisfiedBy) as for CQL, ReversedType is simply an "hint" to the storage engine but it does not change the meaning of queries per-se.

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

#### getString

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

Description copied from class: `AbstractType`
get a string representation of the bytes used for various identifier (NOT just 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>`

#### fromJSONObject

    public Term fromJSONObject(java.lang.Object parsed)
                        throws MarshalException

Description copied from class: `AbstractType`
Given a parsed JSON string, return a byte representation of the object.

Specified by:
  `fromJSONObject` in class `AbstractType<T>`
Parameters:
  `parsed` - the result of parsing a json string
Throws:
  `MarshalException`

#### toJSONString

    public java.lang.String toJSONString(java.nio.ByteBuffer buffer,
                                         ProtocolVersion protocolVersion)

Description copied from class: `AbstractType`
Converts the specified value into its JSON representation.

The buffer position will stay the same.

Overrides:
  `toJSONString` in class `AbstractType<T>`
Parameters:
  `buffer` - the value to convert
  `protocolVersion` - the protocol version to use for the conversion
Returns:
  a JSON string representing the specified value

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

#### referencesUserType

    public boolean referencesUserType(java.lang.String userTypeName)

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

#### valueLengthIfFixed

    protected int valueLengthIfFixed()

Description copied from class: `AbstractType`
The length of values for this type if all values are of fixed length, -1 otherwise.

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

#### isReversed

    public boolean isReversed()

Overrides:
  `isReversed` 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>`