Class AbstractType<T>

    • Field Detail

      • reverseComparator

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

        public final boolean isByteOrderComparable
    • Method Detail

      • asCQLTypeStringList

        public static java.util.List<java.lang.String> asCQLTypeStringList​(java.util.List<AbstractType<?>> abstractTypes)
      • compose

        public final T compose​(java.nio.ByteBuffer bytes)
      • compose

        public <V> T compose​(V value,
                             ValueAccessor<V> accessor)
      • decompose

        public java.nio.ByteBuffer decompose​(T value)
      • getString

        public <V> java.lang.String getString​(V value,
                                              ValueAccessor<V> accessor)
        get a string representation of the bytes used for various identifier (NOT just for log messages)
      • getString

        public final java.lang.String getString​(java.nio.ByteBuffer bytes)
      • 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,
                                             ProtocolVersion protocolVersion)
        Converts the specified value into its JSON representation.

        The buffer position will stay the same.

        Parameters:
        buffer - the value to convert
        protocolVersion - the protocol version to use for the conversion
        Returns:
        a JSON string representing the specified value
      • compare

        public final int compare​(java.nio.ByteBuffer left,
                                 java.nio.ByteBuffer right)
        Specified by:
        compare in interface java.util.Comparator<T>
      • compare

        public final <VL,​VR> int compare​(VL left,
                                               ValueAccessor<VL> accessorL,
                                               VR right,
                                               ValueAccessor<VR> accessorR)
      • compareCustom

        public <VL,​VR> int compareCustom​(VL left,
                                               ValueAccessor<VL> accessorL,
                                               VR right,
                                               ValueAccessor<VR> accessorR)
        Implement IFF ComparisonType is CUSTOM Compares the byte 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
        Parameters:
        left -
        accessorL -
        right -
        accessorR -
      • validateCellValue

        public <V> void validateCellValue​(V cellValue,
                                          ValueAccessor<V> accessor)
                                   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.
      • 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()
      • 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 <VL,​VR> int compareCollectionMembers​(VL left,
                                                          ValueAccessor<VL> accessorL,
                                                          VR right,
                                                          ValueAccessor<VR> accessorR,
                                                          VL 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.
      • isCollection

        public boolean isCollection()
      • isUDT

        public boolean isUDT()
      • isTuple

        public boolean isTuple()
      • isMultiCell

        public boolean isMultiCell()
      • isFreezable

        public boolean isFreezable()
      • subTypes

        public java.util.List<AbstractType<?>> subTypes()
      • freezeNestedMulticellTypes

        public AbstractType<?> freezeNestedMulticellTypes()
        Returns an AbstractType instance that is equivalent to this one, but with all nested UDTs and collections explicitly frozen. This is only necessary for 2.x -> 3.x schema migrations, and can be removed in Cassandra 4.0. See CASSANDRA-11609 and CASSANDRA-11613.
      • 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.
      • 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

        public 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
      • writeValue

        public <V> void writeValue​(V value,
                                   ValueAccessor<V> accessor,
                                   DataOutputPlus out)
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • writtenLength

        public long writtenLength​(java.nio.ByteBuffer value)
      • writtenLength

        public <V> long writtenLength​(V value,
                                      ValueAccessor<V> accessor)
      • readBuffer

        public java.nio.ByteBuffer readBuffer​(DataInputPlus in)
                                       throws java.io.IOException
        Throws:
        java.io.IOException
      • readBuffer

        public java.nio.ByteBuffer readBuffer​(DataInputPlus in,
                                              int maxValueSize)
                                       throws java.io.IOException
        Throws:
        java.io.IOException
      • readArray

        public byte[] readArray​(DataInputPlus in,
                                int maxValueSize)
                         throws java.io.IOException
        Throws:
        java.io.IOException
      • read

        public <V> V read​(ValueAccessor<V> accessor,
                          DataInputPlus in,
                          int maxValueSize)
                   throws java.io.IOException
        Throws:
        java.io.IOException
      • skipValue

        public void skipValue​(DataInputPlus in)
                       throws java.io.IOException
        Throws:
        java.io.IOException
      • referencesUserType

        public final boolean referencesUserType​(java.nio.ByteBuffer name)
      • referencesUserType

        public <V> boolean referencesUserType​(V name,
                                              ValueAccessor<V> accessor)
      • withUpdatedUserType

        public AbstractType<?> withUpdatedUserType​(UserType udt)
        Returns an instance of this type with all references to the provided user type recursively replaced with its new definition.
      • expandUserTypes

        public AbstractType<?> expandUserTypes()
        Replace any instances of UserType with equivalent TupleType-s. We need it for dropped_columns, to allow safely dropping unused user types later without retaining any references to them in system_schema.dropped_columns.
      • referencesDuration

        public boolean referencesDuration()
      • 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()
      • testAssignment

        public final AssignmentTestable.TestResult testAssignment​(java.lang.String keyspace,
                                                                  ColumnSpecification receiver)
        Specified by:
        testAssignment in interface AssignmentTestable
        Returns:
        whether this object can be assigned to the provided receiver. We distinguish between 3 values: - EXACT_MATCH if this object is exactly of the type expected by the receiver - WEAKLY_ASSIGNABLE if this object is not exactly the expected type but is assignable nonetheless - NOT_ASSIGNABLE if it's not assignable Most caller should just call the isAssignable() method on the result, though functions have a use for testing "strong" equality to decide the most precise overload to pick when multiple could match.