private void validateParameterSerializers(ApiParameterConfig config,
    List<Class<? extends Transformer<?, ?>>> serializers, TypeToken<?> parameterType)
    throws ApiParameterConfigInvalidException {
  if (serializers.isEmpty()) {
    return;
  }

  if (serializers.size() > 1) {
    throw new MultipleTransformersException(config, serializers);
  }

  TypeToken<?> sourceType = Serializers.getSourceType(serializers.get(0));
  TypeToken<?> serializedType = Serializers.getTargetType(serializers.get(0));

  if (sourceType == null || serializedType == null) {
    throw new NoTransformerInterfaceException(config, serializers.get(0));
  }

  if (!sourceType.isSupertypeOf(parameterType)) {
    throw new WrongTransformerTypeException(config, serializers.get(0), parameterType,
        sourceType);
  }
}
 

private static <TFrom, TTo> JsonDeserializer<TFrom> getJsonDeserializer(
    @Nullable final Transformer<TFrom, TTo> serializer) {
  if (serializer == null) {
    return null;
  }
  final TypeReference<TTo> serializedType = typeReferenceOf(serializer);
  if (serializer instanceof ResourceTransformer) {
    @SuppressWarnings("unchecked")
    final ResourceTransformer<TFrom> resourceSerializer = (ResourceTransformer<TFrom>) serializer;
    return new ResourceDeserializer<>(resourceSerializer);
  } else {
    return new JsonDeserializer<TFrom>() {
      @Override
      public TFrom deserialize(JsonParser jp, DeserializationContext ctxt)
          throws IOException {
        TTo deserialized = jp.readValueAs(serializedType);
        return serializer.transformFrom(deserialized);
      }
    };
  }
}
 

@SuppressWarnings("unchecked")  // Deliberate bad cast for testing.
public void testMissingSerializerInterface_repeatedItemSerializer() throws Exception {
  final class TestSerializer {}

  config.getApiClassConfig().getMethods()
      .get(methodToEndpointMethod(TestEndpoint.class.getMethod("getResultNoParams")))
      .addParameter("param", null, false, null, TypeToken.of(Integer[].class))
      .setRepeatedItemSerializer(
          (Class<? extends Transformer<?, ?>>) (Class<?>) TestSerializer.class);

  try {
    validator.validate(config);
    fail("Expected NoSerializerInterfaceException.");
  } catch (NoTransformerInterfaceException expected) {
  }
}
 

@Test
public void testInstantiate_typeConstructor() {
  Transformer<List<?>, Type> serializer;
  serializer =
      Serializers.instantiate(ListToTypeSerializer.class, TypeToken.of(ImmutableList.class));
  assertEquals(ImmutableList.class, serializer.transformTo(ImmutableList.of()));
  Type typeWithGeneric = new TypeToken<List<?>>() {}.getType();
  serializer = Serializers.instantiate(ListToTypeSerializer.class, TypeToken.of(typeWithGeneric));
  assertEquals(typeWithGeneric, serializer.transformTo(ImmutableList.of()));
  assertEquals(ImmutableList.of(typeWithGeneric), serializer.transformFrom(List.class));
  try {
    Serializers.instantiate(ListToTypeSerializer.class, TypeToken.of(Collection.class));
    fail("Shouldn't be able to instantiate with Collection");
  } catch (IllegalArgumentException e) {
    // expected
  }
}
 

@SuppressWarnings("unchecked")
private boolean readEndpointClass(ApiConfig config, Class<?> endpointClass, Annotation api,
    Annotation apiClass, @Nullable Class<?> cycleCheck) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException, CyclicApiInheritanceException {
  cycleCheck = checkForInheritanceCycle(endpointClass, cycleCheck);

  boolean hasAnnotation = api != null;
  Class<?> inheritanceSource = determineInheritanceSource(endpointClass);

  if (inheritanceSource != null) {
    Annotation superApi = getDeclaredAnnotation(inheritanceSource, annotationTypes.get("Api"));
    Annotation superApiClass =
        getDeclaredAnnotation(inheritanceSource, annotationTypes.get("ApiClass"));

    hasAnnotation |=
        readEndpointClass(config, inheritanceSource, superApi, superApiClass, cycleCheck);
  }

  if (api != null) {
    readApi(new ApiAnnotationConfig(config), api);
    readApiAuth(new ApiAuthAnnotationConfig(config.getAuthConfig()),
        (Annotation) getAnnotationProperty(api, "auth"));
    readApiFrontendLimits(new ApiFrontendLimitsAnnotationConfig(config.getFrontendLimitsConfig()),
        (Annotation) getAnnotationProperty(api, "frontendLimits"));
    readApiCacheControl(new ApiCacheControlAnnotationConfig(config.getCacheControlConfig()),
        (Annotation) getAnnotationProperty(api, "cacheControl"));
    readApiNamespace(new ApiNamespaceAnnotationConfig(config.getNamespaceConfig()),
        (Annotation) getAnnotationProperty(api, "namespace"));
    readSerializers(config.getSerializationConfig(),
        (Class<? extends Transformer<?, ?>>[]) getAnnotationProperty(api, "transformers"));
  }

  if (apiClass != null) {
    readApiClass(new ApiClassAnnotationConfig(config.getApiClassConfig()), apiClass);
  }

  return hasAnnotation;
}
 

private void readMethodRequestParameter(ApiMethodConfig methodConfig, Annotation parameterName,
    Annotation description, Annotation nullable, Annotation defaultValue, TypeToken<?> type)
    throws IllegalArgumentException, SecurityException, IllegalAccessException, 
    InvocationTargetException, NoSuchMethodException {
  String parameterNameString = null;
  if (parameterName != null) {
    parameterNameString = getAnnotationProperty(parameterName, "value");
  }
  String descriptionString = null;
  if (description != null) {
    descriptionString = getAnnotationProperty(description, "value");
  }
  String defaultValueString = null;
  if (defaultValue != null) {
    defaultValueString = getAnnotationProperty(defaultValue, "value");
  }

  ApiParameterConfig parameterConfig =
      methodConfig.addParameter(parameterNameString, descriptionString, nullable != null, 
          defaultValueString, type);

  Annotation apiSerializer =
      type.getRawType().getAnnotation(annotationTypes.get("ApiTransformer"));
  if (apiSerializer != null) {
    Class<? extends Transformer<?, ?>> serializer =
        getAnnotationProperty(apiSerializer, "value");
    parameterConfig.setSerializer(serializer);
  }

  if (parameterConfig.isRepeated()) {
    TypeToken<?> repeatedItemType = parameterConfig.getRepeatedItemType();
    apiSerializer =
        repeatedItemType.getRawType().getAnnotation(annotationTypes.get("ApiTransformer"));
    if (apiSerializer != null) {
      Class<? extends Transformer<?, ?>> repeatedItemSerializer =
          getAnnotationProperty(apiSerializer, "value");
      parameterConfig.setRepeatedItemSerializer(repeatedItemSerializer);
    }
  }
}
 

@Nullable
private static <TFrom, TTo> JsonSerializer<TFrom> getJsonSerializer(
    @Nullable final Transformer<TFrom, TTo> serializer) {
  if (serializer == null) {
    return null;
  }
  return new JsonSerializer<TFrom>() {
    @Override
    public void serialize(TFrom value, JsonGenerator jgen, SerializerProvider provider)
        throws IOException {
      jgen.writeObject(serializer.transformTo(value));
    }
  };
}
 

/**
 * Gets the schema type for a type. The schema type is identical to the original type if
 * there is no matching {@link com.google.api.server.spi.config.ApiTransformer} annotation for
 * the type. If there is a {@link com.google.api.server.spi.config.ResourceTransformer} installed,
 * the source type determines schema, not the output map.
 */
public static TypeToken<?> getSchemaType(TypeToken<?> type, ApiConfig config) {
  Type rawType = type.getType();
  if (rawType instanceof Class || rawType instanceof ParameterizedType) {
    List<Class<? extends Transformer<?, ?>>> serializers =
        Serializers.getSerializerClasses(type, config.getSerializationConfig());

    if (!serializers.isEmpty() &&
        !(ResourceTransformer.class.isAssignableFrom(serializers.get(0)))) {
      TypeToken<?> sourceType = Serializers.getSourceType(serializers.get(0));
      TypeToken<?> serializedType = Serializers.getTargetType(serializers.get(0));

      Preconditions.checkArgument(
          sourceType.isSupertypeOf(type),
          "Serializer specified for %s, but only serializes for %s: %s",
          type,
          sourceType,
          serializers.get(0));
      Preconditions.checkArgument(
          serializedType != null,
          "Couldn't find Serializer interface in serializer for %s: %s",
          type,
          serializers.get(0));
      return serializedType;
    }
  }
  return type;
}
 

@Nullable
private Transformer<?, ?> findSerializerInstance(Annotated a) {
  if (a instanceof AnnotatedClass) {
    AnnotatedClass clazz = (AnnotatedClass) a;
    List<Class<? extends Transformer<?, ?>>> serializerClasses =
        Serializers.getSerializerClasses(clazz.getRawType(), config);
    if (!serializerClasses.isEmpty()) {
      return Serializers.instantiate(serializerClasses.get(0), TypeToken.of(a.getRawType()));
    }
  }
  return null;
}
 

private static <T> TypeReference<T> typeReferenceOf(Transformer<?, T> serializer) {
  @SuppressWarnings("unchecked")
  Class<? extends Transformer<?, T>> serializerClass =
      (Class<? extends Transformer<?, T>>) serializer.getClass();
  final TypeToken<?> type = Serializers.getTargetType(serializerClass);
  return new TypeReference<T> (){
    @Override
    public Type getType() {
      return type.getType();
    }
  };
}
 

/**
 * Gets a simple name for a type that's suitable for use as a schema name. This will resolve any
 * transformations on the type, which may affect the type name.
 */
public static String getSimpleName(TypeToken<?> type, ApiSerializationConfig config) {
  if (type == null) {
    return null;
  }
  TypeToken<?> itemType = getArrayItemType(type);
  if (itemType != null) {
    return getSimpleName(itemType, config) + "Collection";
  } else if (type.getType() instanceof ParameterizedType) {
    Class<?> clazz = type.getRawType();
    StringBuilder builder = new StringBuilder();
    builder.append(clazz.getSimpleName());
    for (Type typeArg : clazz.getTypeParameters()) {
      builder.append('_');
      builder.append(getSimpleName(type.resolveType(typeArg), config));
    }
    return builder.toString();
  } else {
    Class<? extends Transformer<?, ?>> serializerClass = Iterables.getOnlyElement(
        Serializers.getSerializerClasses(type, config), null);
    if (serializerClass != null && ResourceTransformer.class.isAssignableFrom(serializerClass)) {
      @SuppressWarnings("unchecked")
      ResourceTransformer<?> resourceSerializer =
          (ResourceTransformer<?>) Serializers.instantiate(serializerClass, type);
      ResourceSchema resourceSchema = resourceSerializer.getResourceSchema();
      if (resourceSchema != null && resourceSchema.getName() != null) {
        return resourceSchema.getName();
      }
    }
    String collectionName = FieldType.fromType(type).getCollectionName();
    return collectionName != null ? collectionName : type.getRawType().getSimpleName();
  }
}
 

/**
 * @return The serializer to be used on the parameter.
 */
public List<Class<? extends Transformer<?, ?>>> getSerializers() {
  if (serializer != null) {
    return Collections.<Class<? extends Transformer<?, ?>>>singletonList(serializer);
  } else {
    return tryFindDefaultSerializers(getType());
  }
}
 

/**
 * If the serialized type of the parameter is a repeated type, returns the serializer to be used
 * on each individual item.  Otherwise returns {@code null}.
 */
public List<Class<? extends Transformer<?, ?>>> getRepeatedItemSerializers() {
  if (repeatedItemSerializer != null) {
    return Collections.<Class<? extends Transformer<?, ?>>>singletonList(repeatedItemSerializer);
  } else {
    return tryFindDefaultSerializers(Types.getArrayItemType(getSchemaBaseType()));
  }
}
 

/**
 * Gets the type that acts as the source for schema generation. In the case of resource
 * serialization, the schema is based on the type being serialized. Simple serializers just
 * convert from one type to another, in which case the schema would be derived from the target
 * type instead.
 */
public TypeToken<?> getSchemaBaseType() {
  List<Class<? extends Transformer<?, ?>>> serializers = getSerializers();
  if (serializers.isEmpty()) {
    return getType();
  } else if (ResourceTransformer.class.isAssignableFrom(serializers.get(0))) {
    return getType();
  } else {
    return Serializers.getTargetType(serializers.get(0));
  }
}
 

/**
 * If the serialized type of the parameter is a repeated type, returns the serialized individual
 * item type.  Otherwise returns {@code null}.
 */
public TypeToken<?> getRepeatedItemSerializedType() {
  List<Class<? extends Transformer<?, ?>>> serializers = getRepeatedItemSerializers();
  if (serializers.isEmpty()) {
    return getRepeatedItemType();
  } else {
    return Serializers.getTargetType(serializers.get(0));
  }
}
 

public static List<Class<? extends Transformer<?, ?>>> getSerializerClasses(
    TypeToken<?> type, @Nullable final ApiSerializationConfig config) {
  if (type == null) {
    return Collections.emptyList();
  }

  List<Class<? extends Transformer<?, ?>>> allParentSerializers = Lists.newArrayList();
  List<TypeToken<?>> serializedTypes = Lists.newArrayList();
  for (TypeToken<?> typeToken : type.getTypes()) {
    ApiTransformer apiSerialization = typeToken.getRawType().getAnnotation(ApiTransformer.class);
    if (isSupertypeOf(typeToken, serializedTypes)) {
      continue;
    }
    if (apiSerialization != null) {
      allParentSerializers.add(apiSerialization.value());
      serializedTypes.add(typeToken);
    } else if (config != null) {
      ApiSerializationConfig.SerializerConfig serializerConfig =
          config.getSerializerConfig(typeToken);
      if (serializerConfig != null) {
        allParentSerializers.add(serializerConfig.getSerializer());
        serializedTypes.add(typeToken);
      }
    }
  }

  return allParentSerializers;
}
 

/**
 * Gets the {@code Serializer} source type for a class. This resolves placeholders in generics.
 *
 * @param clazz a class, possibly implementing {@code Transformer}
 * @return the resolved source type, null if clazz is not a serializer
 */
@Nullable
public static TypeToken<?> getSourceType(Class<? extends Transformer<?, ?>> clazz) {
  try {
    TypeToken<?> token = TypeToken.of(clazz);
    return token.resolveType(
        Transformer.class.getMethod("transformFrom", Object.class).getGenericReturnType());
  } catch (NoSuchMethodException e) {
    return null;
  }
}
 

/**
 * Gets the {@code Serializer} target type for a class. This resolves placeholders in generics.
 *
 * @param clazz a class, possibly implementing {@code Transformer}
 * @return the resolved target type, null if clazz is not a serializer
 */
@Nullable
public static TypeToken<?> getTargetType(Class<? extends Transformer<?, ?>> clazz) {
  try {
    TypeToken<?> token = TypeToken.of(clazz);
    return token.resolveType(
        Transformer.class.getMethod("transformTo", Object.class).getGenericReturnType());
  } catch (NoSuchMethodException e) {
    return null;
  }
}
 

@Nullable
private static ParameterizedType getResolvedType(
    @Nullable Class<? extends Transformer<?, ?>> clazz) {
  if (clazz == null || !Transformer.class.isAssignableFrom(clazz)) {
      return null;
  }
  for (TypeToken<?> token : TypeToken.of(clazz).getTypes().interfaces()) {
    if (token.getRawType().equals(Transformer.class)) {
      Type tokenType = token.getType();
      return tokenType instanceof ParameterizedType ? (ParameterizedType) tokenType : null;
    }
  }
  return null;
}
 

@Nullable
private <T> ResourceSchema getResourceSchemaImpl(TypeToken<T> type, ApiConfig config) {
  Class<? super T> clazz = type.getRawType();
  List<Class<? extends Transformer<?, ?>>> serializerClasses =
      Serializers.getSerializerClasses(type, config.getSerializationConfig());
  if (!serializerClasses.isEmpty() &&
      ResourceTransformer.class.isAssignableFrom(serializerClasses.get(0))) {
    @SuppressWarnings("unchecked")
    ResourceTransformer<T> resourceSerializer =
        (ResourceTransformer<T>) Serializers.instantiate(serializerClasses.get(0), type);
    return resourceSerializer.getResourceSchema();
  }
  return null;
}
 

@SuppressWarnings("unchecked")  // Deliberate bad cast for testing.
public void testMissingSerializerInterface() throws Exception {
  final class TestSerializer {}

  config.getApiClassConfig().getMethods()
      .get(methodToEndpointMethod(TestEndpoint.class.getMethod("getResultNoParams")))
      .addParameter("param", null, false, null, TypeToken.of(Integer.class))
      .setSerializer((Class<? extends Transformer<?, ?>>) (Class<?>) TestSerializer.class);

  try {
    validator.validate(config);
    fail("Expected NoSerializerInterfaceException.");
  } catch (NoTransformerInterfaceException expected) {
  }
}
 

@Test
public void testGetSerializerSourceAndTarget_simple() {
  abstract class TestSerializer implements Transformer<Long, Double> {
  }
  assertEquals(TypeToken.of(Long.class), Serializers.getSourceType(TestSerializer.class));
  assertEquals(TypeToken.of(Double.class), Serializers.getTargetType(TestSerializer.class));
}
 

@Test
public void testGetSerializerSourceAndTarget_parameterized() {
  abstract class TestSerializer implements Transformer<List<String>, Map<String, Boolean>> {
  }
  assertEquals(new TypeToken<List<String>>() {},
      Serializers.getSourceType(TestSerializer.class));
  assertEquals(new TypeToken<Map<String, Boolean>>() {},
      Serializers.getTargetType(TestSerializer.class));
}
 

@Test
public void testGetSerializerSourceAndTarget_classInheritance() {
  abstract class ParentTestSerializer<P, Q> implements Transformer<List<P>, Q> {
  }
  abstract class TestSerializer extends ParentTestSerializer<Float, Map<String, Boolean>> {
  }
  assertEquals(new TypeToken<List<Float>>() {},
      Serializers.getSourceType(TestSerializer.class));
  assertEquals(new TypeToken<Map<String, Boolean>>() {},
      Serializers.getTargetType(TestSerializer.class));
}
 

@SuppressWarnings("unchecked")
public void testGetSerializerSourceAndTarget_notSerializers() {
  assertNull(Serializers.getSourceType(null));
  assertNull(Serializers.getTargetType(null));
  assertNull(Serializers.getSourceType(
      (Class<? extends Transformer<?, ?>>) (Class<?>) List.class));
  assertNull(Serializers.getTargetType(
      (Class<? extends Transformer<?, ?>>) (Class<?>) List.class));
}
 

@Test
public void testInstantiate_classConstructor() {
  Transformer<Set<?>, Type> serializer;
  serializer =
      Serializers.instantiate(SetToTypeSerializer.class, TypeToken.of(ImmutableSet.class));
  TypeToken<?> typeWithGeneric = new TypeToken<TreeSet<?>>() {};
  serializer = Serializers.instantiate(SetToTypeSerializer.class, typeWithGeneric);
  assertEquals(TreeSet.class, serializer.transformTo(ImmutableSet.of()));
  try {
    Serializers.instantiate(SetToTypeSerializer.class, TypeToken.of(Collection.class));
    fail("Shouldn't be able to instantiate with Collection");
  } catch (IllegalArgumentException e) {
    // expected
  }
}
 

public WrongTransformerTypeException(ApiParameterConfig config,
    Class<? extends Transformer<?, ?>> transformer, TypeToken<?> parameterType,
    TypeToken<?> sourceType) {
  super(config, getErrorMessage(transformer, parameterType, sourceType));
}
 

private static String getErrorMessage(Class<? extends Transformer<?, ?>> transformer,
    TypeToken<?> parameterType, TypeToken<?> sourceType) {
  return String.format("Bad transformer (%s). Specified for %s, but only transforms %s.",
      transformer, parameterType, sourceType);
}
 

public MultipleTransformersException(ApiParameterConfig config,
    Collection<Class<? extends Transformer<?, ?>>> serializers) {
  super(config, getErrorMessage(serializers));
}
 

private static String getErrorMessage(
    Collection<Class<? extends Transformer<?, ?>>> serializers) {
  return String.format("Found multiple transformers for parameter type. Only one superclass or "
      + "implemented interface may be annotated. Transformed found: %s.", serializers);
}