content: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.datastax.oss.driver.api.core.type.reflect;
  
  import com.datastax.oss.driver.api.core.data.CqlDuration;
  import com.datastax.oss.driver.api.core.data.CqlVector;
  import com.datastax.oss.driver.api.core.data.GettableByIndex;
  import com.datastax.oss.driver.api.core.data.TupleValue;
  import com.datastax.oss.driver.api.core.data.UdtValue;
  import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
  import com.datastax.oss.driver.shaded.guava.common.primitives.Primitives;
  import com.datastax.oss.driver.shaded.guava.common.reflect.TypeParameter;
  import com.datastax.oss.driver.shaded.guava.common.reflect.TypeResolver;
  import com.datastax.oss.driver.shaded.guava.common.reflect.TypeToken;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  import java.lang.reflect.Type;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.net.InetAddress;
  import java.nio.ByteBuffer;
  import java.time.Duration;
  import java.time.Instant;
  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.time.LocalTime;
  import java.time.ZonedDateTime;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.Set;
  import java.util.UUID;
  import net.jcip.annotations.Immutable;
  
  /**
   * Runtime representation of a generic Java type.
   *
   * <p>This is used by type codecs to indicate which Java types they accept ({@link
   * TypeCodec#accepts(GenericType)}), and by generic getters and setters (such as {@link
   * GettableByIndex#get(int, GenericType)} in the driver's query API.
   *
   * <p>There are various ways to build instances of this class:
   *
   * <p>By using one of the static factory methods:
   *
   * <pre>{@code
   * GenericType<List<String>> stringListType = GenericType.listOf(String.class);
   * }</pre>
   *
   * By using an anonymous class:
   *
   * <pre>{@code
   * GenericType<Foo<Bar>> fooBarType = new GenericType<Foo<Bar>>(){};
   * }</pre>
   *
   * In a generic method, by using {@link #where(GenericTypeParameter, GenericType)} to substitute
   * free type variables with runtime types:
   *
   * <pre>{@code
   * <T> GenericType<Optional<T>> optionalOf(GenericType<T> elementType) {
   *   return new GenericType<Optional<T>>() {}
   *     .where(new GenericTypeParameter<T>() {}, elementType);
   * }
   * ...
   * GenericType<Optional<List<String>>> optionalStringListType = optionalOf(GenericType.listOf(String.class));
   * }</pre>
   *
   * <p>You are encouraged to store and reuse these instances.
   *
   * <p>Note that this class is a thin wrapper around Guava's {@code TypeToken}. The only reason why
   * {@code TypeToken} is not used directly is because Guava is not exposed in the driver's public API
   * (it's used internally, but shaded).
   */
  @Immutable
  public class GenericType<T> {
  
    public static final GenericType<Boolean> BOOLEAN = of(Boolean.class);
    public static final GenericType<Byte> BYTE = of(Byte.class);
    public static final GenericType<Double> DOUBLE = of(Double.class);
    public static final GenericType<Float> FLOAT = of(Float.class);
    public static final GenericType<Integer> INTEGER = of(Integer.class);
    public static final GenericType<Long> LONG = of(Long.class);
    public static final GenericType<Short> SHORT = of(Short.class);
    public static final GenericType<Instant> INSTANT = of(Instant.class);
    public static final GenericType<ZonedDateTime> ZONED_DATE_TIME = of(ZonedDateTime.class);
    public static final GenericType<LocalDate> LOCAL_DATE = of(LocalDate.class);
    public static final GenericType<LocalTime> LOCAL_TIME = of(LocalTime.class);
    public static final GenericType<LocalDateTime> LOCAL_DATE_TIME = of(LocalDateTime.class);
    public static final GenericType<ByteBuffer> BYTE_BUFFER = of(ByteBuffer.class);
    public static final GenericType<String> STRING = of(String.class);
    public static final GenericType<BigInteger> BIG_INTEGER = of(BigInteger.class);
    public static final GenericType<BigDecimal> BIG_DECIMAL = of(BigDecimal.class);
    public static final GenericType<UUID> UUID = of(UUID.class);
    public static final GenericType<InetAddress> INET_ADDRESS = of(InetAddress.class);
    public static final GenericType<CqlDuration> CQL_DURATION = of(CqlDuration.class);
    public static final GenericType<TupleValue> TUPLE_VALUE = of(TupleValue.class);
    public static final GenericType<UdtValue> UDT_VALUE = of(UdtValue.class);
    public static final GenericType<Duration> DURATION = of(Duration.class);
  
    @NonNull
    public static <T> GenericType<T> of(@NonNull Class<T> type) {
      return new SimpleGenericType<>(type);
    }
  
    @NonNull
    public static GenericType<?> of(@NonNull java.lang.reflect.Type type) {
      return new GenericType<>(TypeToken.of(type));
    }
  
    @NonNull
    public static <T> GenericType<List<T>> listOf(@NonNull Class<T> elementType) {
      TypeToken<List<T>> token =
          new TypeToken<List<T>>() {}.where(new TypeParameter<T>() {}, TypeToken.of(elementType));
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<List<T>> listOf(@NonNull GenericType<T> elementType) {
      TypeToken<List<T>> token =
          new TypeToken<List<T>>() {}.where(new TypeParameter<T>() {}, elementType.token);
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<Set<T>> setOf(@NonNull Class<T> elementType) {
      TypeToken<Set<T>> token =
          new TypeToken<Set<T>>() {}.where(new TypeParameter<T>() {}, TypeToken.of(elementType));
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<Set<T>> setOf(@NonNull GenericType<T> elementType) {
      TypeToken<Set<T>> token =
          new TypeToken<Set<T>>() {}.where(new TypeParameter<T>() {}, elementType.token);
      return new GenericType<>(token);
    }
  
    @NonNull
    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> 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);
    }
  
    @NonNull
    public static <K, V> GenericType<Map<K, V>> mapOf(
        @NonNull Class<K> keyType, @NonNull Class<V> valueType) {
      TypeToken<Map<K, V>> token =
          new TypeToken<Map<K, V>>() {}.where(new TypeParameter<K>() {}, TypeToken.of(keyType))
              .where(new TypeParameter<V>() {}, TypeToken.of(valueType));
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <K, V> GenericType<Map<K, V>> mapOf(
        @NonNull GenericType<K> keyType, @NonNull GenericType<V> valueType) {
      TypeToken<Map<K, V>> token =
          new TypeToken<Map<K, V>>() {}.where(new TypeParameter<K>() {}, keyType.token)
              .where(new TypeParameter<V>() {}, valueType.token);
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<T[]> arrayOf(@NonNull Class<T> componentType) {
      TypeToken<T[]> token =
          new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, TypeToken.of(componentType));
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<T[]> arrayOf(@NonNull GenericType<T> componentType) {
      TypeToken<T[]> token =
          new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, componentType.token);
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<Optional<T>> optionalOf(@NonNull Class<T> componentType) {
      TypeToken<Optional<T>> token =
          new TypeToken<Optional<T>>() {}.where(
              new TypeParameter<T>() {}, TypeToken.of(componentType));
      return new GenericType<>(token);
    }
  
    @NonNull
    public static <T> GenericType<Optional<T>> optionalOf(@NonNull GenericType<T> componentType) {
      TypeToken<Optional<T>> token =
          new TypeToken<Optional<T>>() {}.where(new TypeParameter<T>() {}, componentType.token);
      return new GenericType<>(token);
    }
  
    private final TypeToken<T> token;
  
    private GenericType(TypeToken<T> token) {
      this.token = token;
    }
  
    protected GenericType() {
      this.token = new TypeToken<T>(getClass()) {};
    }
  
    /**
     * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined
     * according to <a
     * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1">the rules for type
     * arguments</a> introduced with Java generics.
     */
    public final boolean isSupertypeOf(@NonNull GenericType<?> type) {
      return token.isSupertypeOf(type.token);
    }
  
    /**
     * Returns true if this type is a subtype of the given {@code type}. "Subtype" is defined
     * according to <a
     * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1">the rules for type
     * arguments</a> introduced with Java generics.
     */
    public final boolean isSubtypeOf(@NonNull GenericType<?> type) {
      return token.isSubtypeOf(type.token);
    }
  
    /**
     * Returns true if this type is known to be an array type, such as {@code int[]}, {@code T[]},
     * {@code <? extends Map<String, Integer>[]>} etc.
     */
    public final boolean isArray() {
      return token.isArray();
    }
  
    /** Returns true if this type is one of the nine primitive types (including {@code void}). */
    public final boolean isPrimitive() {
      return token.isPrimitive();
    }
  
    /**
     * Returns the corresponding wrapper type if this is a primitive type; otherwise returns {@code
     * this} itself. Idempotent.
     */
    @NonNull
    public final GenericType<T> wrap() {
      if (isPrimitive()) {
        return new GenericType<>(token.wrap());
      }
      return this;
    }
  
    /**
     * Returns the corresponding primitive type if this is a wrapper type; otherwise returns {@code
     * this} itself. Idempotent.
     */
    @NonNull
    public final GenericType<T> unwrap() {
      if (Primitives.allWrapperTypes().contains(token.getRawType())) {
        return new GenericType<>(token.unwrap());
      }
      return this;
    }
  
    /**
     * Substitutes a free type variable with an actual type. See {@link GenericType this class's
     * javadoc} for an example.
     */
    @NonNull
    public final <X> GenericType<T> where(
        @NonNull GenericTypeParameter<X> freeVariable, @NonNull GenericType<X> actualType) {
      TypeResolver resolver =
          new TypeResolver().where(freeVariable.getTypeVariable(), actualType.__getToken().getType());
      Type resolvedType = resolver.resolveType(this.token.getType());
      @SuppressWarnings("unchecked")
      TypeToken<T> resolvedToken = (TypeToken<T>) TypeToken.of(resolvedType);
      return new GenericType<>(resolvedToken);
    }
  
    /**
     * Substitutes a free type variable with an actual type. See {@link GenericType this class's
     * javadoc} for an example.
     */
    @NonNull
    public final <X> GenericType<T> where(
        @NonNull GenericTypeParameter<X> freeVariable, @NonNull Class<X> actualType) {
      return where(freeVariable, GenericType.of(actualType));
    }
  
    /**
     * Returns the array component type if this type represents an array ({@code int[]}, {@code T[]},
     * {@code <? extends Map<String, Integer>[]>} etc.), or else {@code null} is returned.
     */
    @Nullable
    @SuppressWarnings("unchecked")
    public final GenericType<?> getComponentType() {
      TypeToken<?> componentTypeToken = token.getComponentType();
      return (componentTypeToken == null) ? null : new GenericType(componentTypeToken);
    }
  
    /**
     * Returns the raw type of {@code T}. Formally speaking, if {@code T} is returned by {@link
     * java.lang.reflect.Method#getGenericReturnType}, the raw type is what's returned by {@link
     * java.lang.reflect.Method#getReturnType} of the same method object. Specifically:
     *
     * <ul>
     *   <li>If {@code T} is a {@code Class} itself, {@code T} itself is returned.
     *   <li>If {@code T} is a parameterized type, the raw type of the parameterized type is returned.
     *   <li>If {@code T} is an array type , the returned type is the corresponding array class. For
     *       example: {@code List<Integer>[] => List[]}.
     *   <li>If {@code T} is a type variable or a wildcard type, the raw type of the first upper bound
     *       is returned. For example: {@code <X extends Foo> => Foo}.
     * </ul>
     */
    @NonNull
    public Class<? super T> getRawType() {
      return token.getRawType();
    }
  
    /**
     * Returns the generic form of {@code superclass}. For example, if this is {@code
     * ArrayList<String>}, {@code Iterable<String>} is returned given the input {@code
     * Iterable.class}.
     */
    @SuppressWarnings("unchecked")
    @NonNull
    public final GenericType<? super T> getSupertype(@NonNull Class<? super T> superclass) {
      return new GenericType(token.getSupertype(superclass));
    }
  
    /**
     * Returns subtype of {@code this} with {@code subclass} as the raw class. For example, if this is
     * {@code Iterable<String>} and {@code subclass} is {@code List}, {@code List<String>} is
     * returned.
     */
    @SuppressWarnings("unchecked")
    @NonNull
    public final GenericType<? extends T> getSubtype(@NonNull Class<?> subclass) {
      return new GenericType(token.getSubtype(subclass));
    }
  
    /** Returns the represented type. */
    @NonNull
    public final Type getType() {
      return token.getType();
    }
  
    /**
     * This method is for internal use, <b>DO NOT use it from client code</b>.
     *
     * <p>It leaks a shaded type. This should be part of the internal API, but due to internal
     * implementation details it has to be exposed here.
     *
     * @leaks-private-api
     */
    @NonNull
    public TypeToken<T> __getToken() {
      return token;
    }
  
    @Override
    public boolean equals(Object other) {
      if (other == this) {
        return true;
      } else if (other instanceof GenericType) {
        GenericType that = (GenericType) other;
        return this.token.equals(that.token);
      } else {
        return false;
      }
    }
  
    @Override
    public int hashCode() {
      return token.hashCode();
    }
  
    @Override
    public String toString() {
      return token.toString();
    }
  
    private static class SimpleGenericType<T> extends GenericType<T> {
      SimpleGenericType(Class<T> type) {
        super(TypeToken.of(type));
      }
    }
  }
  