Refactor CqlVector to generic type

SiyaoIsHiding · SiyaoIsHiding · commit 3bbd51947565 · 2024-08-14T00:14:59.000-07:00
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java
@@ -52,15 +52,15 @@
  * where possible we've tried to make the API of this class similar to the equivalent methods on
  * {@link List}.
  */
-public class CqlVector<T extends Number> implements Iterable<T>, Serializable {
+public class CqlVector<T> implements Iterable<T>, Serializable {
 
   /**
    * Create a new CqlVector containing the specified values.
    *
    * @param vals the collection of values to wrap.
    * @return a CqlVector wrapping those values
    */
-  public static <V extends Number> CqlVector<V> newInstance(V... vals) {
+  public static <V> CqlVector<V> newInstance(V... vals) {
 
     // Note that Array.asList() guarantees the return of an array which implements RandomAccess
     return new CqlVector(Arrays.asList(vals));
@@ -73,7 +73,7 @@ public static <V extends Number> CqlVector<V> newInstance(V... vals) {
    * @param list the collection of values to wrap.
    * @return a CqlVector wrapping those values
    */
-  public static <V extends Number> CqlVector<V> newInstance(List<V> list) {
+  public static <V> CqlVector<V> newInstance(List<V> list) {
     Preconditions.checkArgument(list != null, "Input list should not be null");
     return new CqlVector(list);
   }
@@ -87,8 +87,7 @@ public static <V extends Number> CqlVector<V> newInstance(List<V> list) {
    * @param subtypeCodec
    * @return a new CqlVector built from the String representation
    */
-  public static <V extends Number> CqlVector<V> from(
-      @NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
+  public static <V> CqlVector<V> from(@NonNull String str, @NonNull TypeCodec<V> subtypeCodec) {
     Preconditions.checkArgument(str != null, "Cannot create CqlVector from null string");
     Preconditions.checkArgument(!str.isEmpty(), "Cannot create CqlVector from empty string");
     ArrayList<V> vals =
@@ -205,7 +204,7 @@ public String toString() {
    *
    * @param <T> inner type of CqlVector, assume Number is always Serializable.
    */
-  private static class SerializationProxy<T extends Number> implements Serializable {
+  private static class SerializationProxy<T> implements Serializable {
 
     private static final long serialVersionUID = 1;
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableById.java
@@ -531,7 +531,7 @@ default CqlDuration getCqlDuration(@NonNull CqlIdentifier id) {
    * @throws IllegalArgumentException if the id is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
+  default <ElementT> CqlVector<ElementT> getVector(
       @NonNull CqlIdentifier id, @NonNull Class<ElementT> elementsClass) {
     return getVector(firstIndexOf(id), elementsClass);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByIndex.java
@@ -446,8 +446,7 @@ default CqlDuration getCqlDuration(int i) {
    * @throws IndexOutOfBoundsException if the index is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
-      int i, @NonNull Class<ElementT> elementsClass) {
+  default <ElementT> CqlVector<ElementT> getVector(int i, @NonNull Class<ElementT> elementsClass) {
     return get(i, GenericType.vectorOf(elementsClass));
   }
 
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/GettableByName.java
@@ -527,7 +527,7 @@ default CqlDuration getCqlDuration(@NonNull String name) {
    * @throws IllegalArgumentException if the name is invalid.
    */
   @Nullable
-  default <ElementT extends Number> CqlVector<ElementT> getVector(
+  default <ElementT> CqlVector<ElementT> getVector(
       @NonNull String name, @NonNull Class<ElementT> elementsClass) {
     return getVector(firstIndexOf(name), elementsClass);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableById.java
@@ -573,7 +573,7 @@ default SelfT setCqlDuration(@NonNull CqlIdentifier id, @Nullable CqlDuration v)
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       @NonNull CqlIdentifier id,
       @Nullable CqlVector<ElementT> v,
       @NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByIndex.java
@@ -425,7 +425,7 @@ default SelfT setCqlDuration(int i, @Nullable CqlDuration v) {
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       int i, @Nullable CqlVector<ElementT> v, @NonNull Class<ElementT> elementsClass) {
     return set(i, v, GenericType.vectorOf(elementsClass));
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java b/core/src/main/java/com/datastax/oss/driver/api/core/data/SettableByName.java
@@ -572,7 +572,7 @@ default SelfT setCqlDuration(@NonNull String name, @Nullable CqlDuration v) {
    */
   @NonNull
   @CheckReturnValue
-  default <ElementT extends Number> SelfT setVector(
+  default <ElementT> SelfT setVector(
       @NonNull String name,
       @Nullable CqlVector<ElementT> v,
       @NonNull Class<ElementT> elementsClass) {
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/codec/TypeCodecs.java
@@ -210,13 +210,13 @@ public static TypeCodec<TupleValue> tupleOf(@NonNull TupleType cqlType) {
     return new TupleCodec(cqlType);
   }
 
-  public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+  public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
       @NonNull VectorType type, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
     return new VectorCodec(
         DataTypes.vectorOf(subtypeCodec.getCqlType(), type.getDimensions()), subtypeCodec);
   }
 
-  public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(
+  public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(
       int dimensions, @NonNull TypeCodec<SubtypeT> subtypeCodec) {
     return new VectorCodec(DataTypes.vectorOf(subtypeCodec.getCqlType(), dimensions), subtypeCodec);
   }
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java b/core/src/main/java/com/datastax/oss/driver/api/core/type/reflect/GenericType.java
@@ -151,17 +151,15 @@ public static <T> GenericType<Set<T>> setOf(@NonNull GenericType<T> elementType)
   }
 
   @NonNull
-  public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
-      @NonNull Class<T> elementType) {
+  public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull Class<T> elementType) {
     TypeToken<CqlVector<T>> token =
         new TypeToken<CqlVector<T>>() {}.where(
             new TypeParameter<T>() {}, TypeToken.of(elementType));
     return new GenericType<>(token);
   }
 
   @NonNull
-  public static <T extends Number> GenericType<CqlVector<T>> vectorOf(
-      @NonNull GenericType<T> elementType) {
+  public static <T> GenericType<CqlVector<T>> vectorOf(@NonNull GenericType<T> elementType) {
     TypeToken<CqlVector<T>> token =
         new TypeToken<CqlVector<T>>() {}.where(new TypeParameter<T>() {}, elementType.token);
     return new GenericType<>(token);
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java
@@ -33,7 +33,7 @@
 import java.util.List;
 import java.util.NoSuchElementException;
 
-public class VectorCodec<SubtypeT extends Number> implements TypeCodec<CqlVector<SubtypeT>> {
+public class VectorCodec<SubtypeT extends DataType> implements TypeCodec<CqlVector<SubtypeT>> {
 
   private final VectorType cqlType;
   private final GenericType<CqlVector<SubtypeT>> javaType;
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java b/core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistry.java
@@ -394,10 +394,9 @@ protected GenericType<?> inspectType(@NonNull Object value, @Nullable DataType c
               "Can't infer vector codec because the first element is null "
                   + "(note that CQL does not allow null values in collections)");
         }
-        GenericType<? extends Number> elementType =
-            (GenericType<? extends Number>)
-                inspectType(
-                    firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
+        GenericType<?> elementType =
+            inspectType(
+                firstElement, cqlType == null ? null : ((VectorType) cqlType).getElementType());
         return GenericType.vectorOf(elementType);
       }
     } else {
@@ -421,8 +420,7 @@ protected GenericType<?> inferJavaTypeFromCqlType(@NonNull DataType cqlType) {
           inferJavaTypeFromCqlType(keyType), inferJavaTypeFromCqlType(valueType));
     } else if (cqlType instanceof VectorType) {
       DataType elementType = ((VectorType) cqlType).getElementType();
-      GenericType<? extends Number> numberType =
-          (GenericType<? extends Number>) inferJavaTypeFromCqlType(elementType);
+      GenericType<?> numberType = inferJavaTypeFromCqlType(elementType);
       return GenericType.vectorOf(numberType);
     }
     switch (cqlType.getProtocolCode()) {
@@ -657,7 +655,7 @@ protected TypeCodec<?> createCodec(
         /* For a vector type we'll always get back an instance of TypeCodec<? extends Number> due to the
          * type of CqlVector... but getElementCodecForCqlAndJavaType() is a generalized function that can't
          * return this more precise type.  Thus the cast here. */
-        TypeCodec<? extends Number> elementCodec =
+        TypeCodec<?> elementCodec =
             uncheckedCast(getElementCodecForCqlAndJavaType(vectorType, token, isJavaCovariant));
         return TypeCodecs.vectorOf(vectorType, elementCodec);
       } else if (cqlType instanceof CustomType
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java
@@ -29,6 +29,7 @@
 import java.util.Arrays;
 import org.junit.Test;
 
+/** Only for Float TODO: add others */
 public class VectorCodecTest extends CodecTestBase<CqlVector<Float>> {
 
   private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
diff --git a/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java b/integration-tests/src/test/java/com/datastax/oss/driver/core/data/DataTypeIT.java
@@ -54,7 +54,6 @@
 import com.datastax.oss.driver.internal.core.type.DefaultSetType;
 import com.datastax.oss.driver.internal.core.type.DefaultTupleType;
 import com.datastax.oss.driver.internal.core.type.DefaultUserDefinedType;
-import com.datastax.oss.driver.internal.core.type.DefaultVectorType;
 import com.datastax.oss.protocol.internal.ProtocolConstants;
 import com.datastax.oss.protocol.internal.util.Bytes;
 import com.tngtech.java.junit.dataprovider.DataProvider;
@@ -265,10 +264,10 @@ public static Object[][] typeSamples() {
               UdtValue udtValue2 = udt.newValue(1, o[1]);
               samples.add(new Object[] {udt, udtValue2});
 
+              // change the vector subtype into arbitrary type
               if (o[0] == DataTypes.INT) {
                 CqlVector<Float> vector = CqlVector.newInstance(1.1f, 2.2f, 3.3f);
-                samples.add(new Object[]{DataTypes.vectorOf(DataTypes.FLOAT, 3),
-                        vector});
+                samples.add(new Object[] {DataTypes.vectorOf(DataTypes.FLOAT, 3), vector});
               }
               return samples.stream();
             })

Original file line number	Diff line number	Diff line change
`@@ -531,7 +531,7 @@ default CqlDuration getCqlDuration(@NonNull CqlIdentifier id) {`
`531`	`531`	`* @throws IllegalArgumentException if the id is invalid.`
`532`	`532`	`*/`
`533`	`533`	`@Nullable`
`534`		`- default <ElementT extends Number> CqlVector<ElementT> getVector(`
	`534`	`+ default <ElementT> CqlVector<ElementT> getVector(`
`535`	`535`	`@NonNull CqlIdentifier id, @NonNull Class<ElementT> elementsClass) {`
`536`	`536`	`return getVector(firstIndexOf(id), elementsClass);`
`537`	`537`	`}`
Original file line number	Diff line number	Diff line change
`@@ -446,8 +446,7 @@ default CqlDuration getCqlDuration(int i) {`
`446`	`446`	`* @throws IndexOutOfBoundsException if the index is invalid.`
`447`	`447`	`*/`
`448`	`448`	`@Nullable`
`449`		`- default <ElementT extends Number> CqlVector<ElementT> getVector(`
`450`		`- int i, @NonNull Class<ElementT> elementsClass) {`
	`449`	`+ default <ElementT> CqlVector<ElementT> getVector(int i, @NonNull Class<ElementT> elementsClass) {`
`451`	`450`	`return get(i, GenericType.vectorOf(elementsClass));`
`452`	`451`	`}`
`453`	`452`
Original file line number	Diff line number	Diff line change
`@@ -527,7 +527,7 @@ default CqlDuration getCqlDuration(@NonNull String name) {`
`527`	`527`	`* @throws IllegalArgumentException if the name is invalid.`
`528`	`528`	`*/`
`529`	`529`	`@Nullable`
`530`		`- default <ElementT extends Number> CqlVector<ElementT> getVector(`
	`530`	`+ default <ElementT> CqlVector<ElementT> getVector(`
`531`	`531`	`@NonNull String name, @NonNull Class<ElementT> elementsClass) {`
`532`	`532`	`return getVector(firstIndexOf(name), elementsClass);`
`533`	`533`	`}`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ default SelfT setCqlDuration(int i, @Nullable CqlDuration v) {`
`425`	`425`	`*/`
`426`	`426`	`@NonNull`
`427`	`427`	`@CheckReturnValue`
`428`		`- default <ElementT extends Number> SelfT setVector(`
	`428`	`+ default <ElementT> SelfT setVector(`
`429`	`429`	`int i, @Nullable CqlVector<ElementT> v, @NonNull Class<ElementT> elementsClass) {`
`430`	`430`	`return set(i, v, GenericType.vectorOf(elementsClass));`
`431`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -210,13 +210,13 @@ public static TypeCodec<TupleValue> tupleOf(@NonNull TupleType cqlType) {`
`210`	`210`	`return new TupleCodec(cqlType);`
`211`	`211`	`}`
`212`	`212`
`213`		`- public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(`
	`213`	`+ public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(`
`214`	`214`	`@NonNull VectorType type, @NonNull TypeCodec<SubtypeT> subtypeCodec) {`
`215`	`215`	`return new VectorCodec(`
`216`	`216`	`DataTypes.vectorOf(subtypeCodec.getCqlType(), type.getDimensions()), subtypeCodec);`
`217`	`217`	`}`
`218`	`218`
`219`		`- public static <SubtypeT extends Number> TypeCodec<CqlVector<SubtypeT>> vectorOf(`
	`219`	`+ public static <SubtypeT> TypeCodec<CqlVector<SubtypeT>> vectorOf(`
`220`	`220`	`int dimensions, @NonNull TypeCodec<SubtypeT> subtypeCodec) {`
`221`	`221`	`return new VectorCodec(DataTypes.vectorOf(subtypeCodec.getCqlType(), dimensions), subtypeCodec);`
`222`	`222`	`}`