## org.apache.cassandra.db.marshal
Class AbstractType<T>

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

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

Direct Known Subclasses:
  AbstractCommutativeType, AbstractCompositeType, AsciiType, BooleanType, BytesType, DateType, DecimalType, DoubleType, FloatType, Int32Type, IntegerType, LexicalUUIDType, LocalByPartionerType, LongType, ReversedType, TimeUUIDType, UTF8Type, UUIDType

    public abstract class AbstractType<T>

extends java.lang.Object
implements java.util.Comparator<java.nio.ByteBuffer>

Specifies a Comparator for a specific type of ByteBuffer. Note that empty ByteBuffer are used to represent "start at the beginning" or "stop at the end" arguments to get_slice, so the Comparator should always handle those values even if they normally do not represent a valid ByteBuffer for the type being compared.

Field Summary
`java.util.Comparator<IColumn>` `columnComparator`
`java.util.Comparator<IColumn>` `columnReverseComparator`
`java.util.Comparator<IndexHelper.IndexInfo>` `indexComparator`
`java.util.Comparator<IndexHelper.IndexInfo>` `indexReverseComparator`
`java.util.Comparator<java.nio.ByteBuffer>` `reverseComparator`

Constructor Summary
`protected` `AbstractType()`

Method Summary
`abstract T` `compose(java.nio.ByteBuffer bytes)`
`abstract java.nio.ByteBuffer` `decompose(T value)`
`abstract java.nio.ByteBuffer` `fromString(java.lang.String source)` get a byte representation of the given string.
`java.lang.String` `getColumnsString(java.util.Collection<IColumn> columns)`
`java.util.Comparator<java.nio.ByteBuffer>` `getReverseComparator()` Deprecated. use reverseComparator field instead
`abstract java.lang.String` `getString(java.nio.ByteBuffer bytes)` get a string representation of the bytes suitable for log messages
`java.lang.String` `getString(java.util.Collection<java.nio.ByteBuffer> names)`
`boolean` `isCommutative()`
`boolean` `isCompatibleWith(AbstractType<?> previous)` Returns true if this comparator is compatible with the provided previous comparator, that is if previous can safely be replaced by this.
`static AbstractType<?>` `parseDefaultParameters(AbstractType<?> baseType, TypeParser parser)`
`java.lang.String` `toString()` This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).
`abstract void` `validate(java.nio.ByteBuffer bytes)`

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

Methods inherited from interface java.util.Comparator
`compare, equals`

Field Detail

### indexComparator

    public final java.util.Comparator<IndexHelper.IndexInfo> indexComparator

### indexReverseComparator

    public final java.util.Comparator<IndexHelper.IndexInfo> indexReverseComparator

### columnComparator

    public final java.util.Comparator<IColumn> columnComparator

### columnReverseComparator

    public final java.util.Comparator<IColumn> columnReverseComparator

### reverseComparator

    public final java.util.Comparator<java.nio.ByteBuffer> reverseComparator

Constructor Detail

### AbstractType

    protected AbstractType()

Method Detail

### compose

    public abstract T compose(java.nio.ByteBuffer bytes)

### decompose

    public abstract java.nio.ByteBuffer decompose(T value)

### getString

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

  get a string representation of the bytes suitable for log messages

### fromString

    public abstract java.nio.ByteBuffer fromString(java.lang.String source)
                                            throws MarshalException

  get a byte representation of the given string.

  Throws:
    `MarshalException`

### validate

    public abstract void validate(java.nio.ByteBuffer bytes)
                           throws MarshalException

  Throws:
    `MarshalException`

### getReverseComparator

    public java.util.Comparator<java.nio.ByteBuffer> getReverseComparator()

  Deprecated. use reverseComparator field instead

### getString

    public java.lang.String getString(java.util.Collection<java.nio.ByteBuffer> names)

### getColumnsString

    public java.lang.String getColumnsString(java.util.Collection<IColumn> columns)

### isCommutative

    public boolean isCommutative()

### parseDefaultParameters

    public static AbstractType<?> parseDefaultParameters(AbstractType<?> baseType,
                                                         TypeParser parser)
                                                  throws ConfigurationException

  Throws:
    `ConfigurationException`

### isCompatibleWith

    public boolean isCompatibleWith(AbstractType<?> previous)

  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!

### toString

    public java.lang.String toString()

  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 `java.lang.Object`

Copyright © 2013 The Apache Software Foundation