AbstractType (apache-cassandra API)

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

All Implemented Interfaces:

java.util.Comparator<java.nio.ByteBuffer>

Direct Known Subclasses:

AbstractCompositeType, AsciiType, BooleanType, BytesType, ByteType, CollectionType, ColumnToCollectionType, CounterColumnType, DateType, DecimalType, DoubleType, EmptyType, FloatType, FrozenType, InetAddressType, Int32Type, IntegerType, LexicalUUIDType, LongType, PartitionerDefinedOrder, ReversedType, ShortType, SimpleDateType, TimestampType, TimeType, TimeUUIDType, TupleType, 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.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AbstractType.ComparisonType

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractType.ComparisonType`

Field Summary

Fields
Modifier and Type Field and Description

AbstractType.ComparisonType comparisonType

boolean isByteOrderComparable

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

Fields
Modifier and Type	Field and Description
`AbstractType.ComparisonType`	`comparisonType`
`boolean`	`isByteOrderComparable`
`java.util.Comparator<java.nio.ByteBuffer>`	`reverseComparator`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractType(AbstractType.ComparisonType comparisonType)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractType(AbstractType.ComparisonType comparisonType)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`CQL3Type`	`asCQL3Type()`
`static java.util.List<java.lang.String>`	`asCQLTypeStringList(java.util.List<AbstractType<?>> abstractTypes)`
`void`	`checkComparable()`
`int`	`compare(java.nio.ByteBuffer left, java.nio.ByteBuffer right)`
`int`	`compareCollectionMembers(java.nio.ByteBuffer v1, java.nio.ByteBuffer v2, java.nio.ByteBuffer collectionName)` An alternative comparison function used by CollectionsType in conjunction with CompositeType.
`int`	`compareCustom(java.nio.ByteBuffer left, java.nio.ByteBuffer right)` 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.
`int`	`componentsCount()` The number of subcomponents this type has.
`T`	`compose(java.nio.ByteBuffer bytes)`
`java.nio.ByteBuffer`	`decompose(T value)`
`AbstractType<?>`	`freeze()`
`abstract Term`	`fromJSONObject(java.lang.Object parsed)` Given a parsed JSON string, return a byte representation of the object.
`abstract java.nio.ByteBuffer`	`fromString(java.lang.String source)` get a byte representation of the given string.
`java.util.List<AbstractType<?>>`	`getComponents()` Return a list of the "subcomponents" this type has.
`abstract 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)
`java.lang.String`	`getString(java.util.Collection<java.nio.ByteBuffer> names)`
`boolean`	`isCollection()`
`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.
`boolean`	`isCounter()`
`boolean`	`isEmptyValueMeaningless()` Returns `true` for types where empty should be handled like `null` like `Int32Type`.
`boolean`	`isFrozenCollection()`
`boolean`	`isMultiCell()`
`boolean`	`isReversed()`
`boolean`	`isValueCompatibleWith(AbstractType<?> otherType)` Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType.
`protected boolean`	`isValueCompatibleWithInternal(AbstractType<?> otherType)` Needed to handle ReversedType in value-compatibility checks.
`static AbstractType<?>`	`parseDefaultParameters(AbstractType<?> baseType, TypeParser parser)`
`java.nio.ByteBuffer`	`readValue(DataInputPlus in)`
`boolean`	`references(AbstractType<?> check)` Checks whether this type or any of the types this type contains references the given type.
`void`	`skipValue(DataInputPlus in)`
`java.lang.String`	`toJSONString(java.nio.ByteBuffer buffer, int protocolVersion)` Converts a value to a JSON string.
`java.lang.String`	`toString()` This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).
`java.lang.String`	`toString(boolean ignoreFreezing)`
`void`	`validate(java.nio.ByteBuffer bytes)`
`void`	`validateCellValue(java.nio.ByteBuffer cellValue)` Validate cell value.
`void`	`validateCollectionMember(java.nio.ByteBuffer bytes, java.nio.ByteBuffer collectionName)` An alternative validation function used by CollectionsType in conjunction with CompositeType.
`protected int`	`valueLengthIfFixed()` The length of values for this type if all values are of fixed length, -1 otherwise.
`void`	`writeValue(java.nio.ByteBuffer value, DataOutputPlus out)`
`long`	`writtenLength(java.nio.ByteBuffer value)`

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
  - reverseComparator
```
public final java.util.Comparator<java.nio.ByteBuffer> reverseComparator
```
  - comparisonType
```
public final AbstractType.ComparisonType comparisonType
```
  - isByteOrderComparable
```
public final boolean isByteOrderComparable
```
- Constructor Detail
  - AbstractType
```
protected AbstractType(AbstractType.ComparisonType comparisonType)
```
- Method Detail
  - asCQLTypeStringList
```
public static java.util.List<java.lang.String> asCQLTypeStringList(java.util.List<AbstractType<?>> abstractTypes)
```
  - compose
```
public T compose(java.nio.ByteBuffer bytes)
```
  - decompose
```
public java.nio.ByteBuffer decompose(T value)
```
  - getString
```
public java.lang.String getString(java.nio.ByteBuffer bytes)
```
    get a string representation of the bytes used for various identifier (NOT just 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
  - fromJSONObject
```
public abstract Term fromJSONObject(java.lang.Object parsed)
                             throws MarshalException
```
    Given a parsed JSON string, return a byte representation of the object.
    
    Parameters:
    
    parsed - the result of parsing a json string
    
    Throws:
    
    MarshalException
  - toJSONString
```
public java.lang.String toJSONString(java.nio.ByteBuffer buffer,
                                     int protocolVersion)
```
    Converts a value to a JSON string.
  - validate
```
public void validate(java.nio.ByteBuffer bytes)
              throws MarshalException
```
    Throws:
    
    MarshalException
  - compare
```
public final int compare(java.nio.ByteBuffer left,
                         java.nio.ByteBuffer right)
```
    Specified by:
    
    compare in interface java.util.Comparator<java.nio.ByteBuffer>
  - compareCustom
```
public int compareCustom(java.nio.ByteBuffer left,
                         java.nio.ByteBuffer right)
```
    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
  - validateCellValue
```
public void validateCellValue(java.nio.ByteBuffer cellValue)
                       throws MarshalException
```
    Validate cell value. Unlike validate(java.nio.ByteBuffer), cell value is passed to validate its content. Usually, this is the same as validate except collection.
    
    Parameters:
    
    cellValue - ByteBuffer representing cell value
    
    Throws:
    
    MarshalException
  - asCQL3Type
```
public CQL3Type asCQL3Type()
```
  - compareForCQL
```
public int compareForCQL(java.nio.ByteBuffer v1,
                         java.nio.ByteBuffer v2)
```
    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.
  - getSerializer
```
public abstract TypeSerializer<T> getSerializer()
```
  - getString
```
public java.lang.String getString(java.util.Collection<java.nio.ByteBuffer> names)
```
  - isCounter
```
public boolean isCounter()
```
  - isFrozenCollection
```
public boolean isFrozenCollection()
```
  - isReversed
```
public boolean isReversed()
```
  - parseDefaultParameters
```
public static AbstractType<?> parseDefaultParameters(AbstractType<?> baseType,
                                                     TypeParser parser)
                                              throws SyntaxException
```
    Throws:
    
    SyntaxException
  - 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!
  - isValueCompatibleWith
```
public boolean isValueCompatibleWith(AbstractType<?> otherType)
```
    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.
  - isValueCompatibleWithInternal
```
protected boolean isValueCompatibleWithInternal(AbstractType<?> otherType)
```
    Needed to handle ReversedType in value-compatibility checks. Subclasses should implement this instead of isValueCompatibleWith().
  - compareCollectionMembers
```
public int compareCollectionMembers(java.nio.ByteBuffer v1,
                                    java.nio.ByteBuffer v2,
                                    java.nio.ByteBuffer collectionName)
```
    An alternative comparison function used by CollectionsType in conjunction with CompositeType. This comparator is only called to compare components of a CompositeType. It gets the value of the previous component as argument (or null if it's the first component of the composite). Unless you're doing something very similar to CollectionsType, you shouldn't override this.
  - validateCollectionMember
```
public void validateCollectionMember(java.nio.ByteBuffer bytes,
                                     java.nio.ByteBuffer collectionName)
                              throws MarshalException
```
    An alternative validation function used by CollectionsType in conjunction with CompositeType. This is similar to the compare function above.
    
    Throws:
    
    MarshalException
  - isCollection
```
public boolean isCollection()
```
  - isMultiCell
```
public boolean isMultiCell()
```
  - freeze
```
public AbstractType<?> freeze()
```
  - isEmptyValueMeaningless
```
public boolean isEmptyValueMeaningless()
```
    Returns true for types where empty should be handled like null like Int32Type.
  - toString
```
public java.lang.String toString(boolean ignoreFreezing)
```
    Parameters:
    
    ignoreFreezing - if true, the type string will not be wrapped with FrozenType(...), even if this type is frozen.
  - componentsCount
```
public int componentsCount()
```
    The number of subcomponents this type has. This is always 1, i.e. the type has only itself as "subcomponents", except for CompositeType.
  - getComponents
```
public java.util.List<AbstractType<?>> getComponents()
```
    Return a list of the "subcomponents" this type has. This always return a singleton list with the type itself except for CompositeType.
  - valueLengthIfFixed
```
protected int valueLengthIfFixed()
```
    The length of values for this type if all values are of fixed length, -1 otherwise.
  - writeValue
```
public void writeValue(java.nio.ByteBuffer value,
                       DataOutputPlus out)
                throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writtenLength
```
public long writtenLength(java.nio.ByteBuffer value)
```
  - readValue
```
public java.nio.ByteBuffer readValue(DataInputPlus in)
                              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - skipValue
```
public void skipValue(DataInputPlus in)
               throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - references
```
public boolean references(AbstractType<?> check)
```
    Checks whether this type or any of the types this type contains references the given type.
  - 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
  - checkComparable
```
public void checkComparable()
```

Class AbstractType<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Comparator

Field Detail

reverseComparator

comparisonType

isByteOrderComparable

Constructor Detail

AbstractType

Method Detail

asCQLTypeStringList

compose

decompose

getString

fromString

fromJSONObject

toJSONString

validate

compare

compareCustom

validateCellValue

asCQL3Type

compareForCQL

getSerializer

getString

isCounter

isFrozenCollection

isReversed

parseDefaultParameters

isCompatibleWith

isValueCompatibleWith

isValueCompatibleWithInternal

compareCollectionMembers

validateCollectionMember

isCollection

isMultiCell

freeze

isEmptyValueMeaningless

toString

componentsCount

getComponents

valueLengthIfFixed

writeValue

writtenLength

readValue

skipValue

references

toString

checkComparable