Java WildcardTypeName.subtypeOf方法代码示例

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
private List<MethodSpec> generateConstructors() {
  ParameterizedTypeName classOfTranscodeType =
      ParameterizedTypeName.get(ClassName.get(Class.class), transcodeTypeName);

  TypeName wildcardOfObject = WildcardTypeName.subtypeOf(Object.class);
  ParameterizedTypeName requestBuilderOfWildcardOfObject =
      ParameterizedTypeName.get(ClassName.get(requestBuilderType), wildcardOfObject);

  MethodSpec firstConstructor =
      MethodSpec.constructorBuilder()
          .addParameter(classOfTranscodeType, "transcodeClass")
          .addParameter(requestBuilderOfWildcardOfObject, "other")
      .addStatement("super($N, $N)", "transcodeClass", "other")
      .build();

  ClassName glide = ClassName.get("com.bumptech.glide", "Glide");
  ClassName requestManager = ClassName.get("com.bumptech.glide", "RequestManager");
  MethodSpec secondConstructor =
      MethodSpec.constructorBuilder()
          .addParameter(glide, "glide")
          .addParameter(requestManager, "requestManager")
          .addParameter(classOfTranscodeType, "transcodeClass")
          .addStatement("super($N, $N ,$N)", "glide", "requestManager", "transcodeClass")
          .build();
  return ImmutableList.of(firstConstructor, secondConstructor);
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
private MethodSpec generateGetExcludedModuleClasses(Set<String> excludedClassNames) {
  TypeName wildCardOfObject = WildcardTypeName.subtypeOf(Object.class);
  ParameterizedTypeName classOfWildcardOfObjet =
      ParameterizedTypeName.get(ClassName.get(Class.class), wildCardOfObject);
  ParameterizedTypeName setOfClassOfWildcardOfObject =
      ParameterizedTypeName.get(ClassName.get(Set.class), classOfWildcardOfObjet);
  ParameterizedTypeName hashSetOfClassOfWildcardOfObject =
      ParameterizedTypeName.get(ClassName.get(HashSet.class), classOfWildcardOfObjet);
  MethodSpec.Builder builder = MethodSpec.methodBuilder("getExcludedModuleClasses")
      .addModifiers(Modifier.PUBLIC)
      .addAnnotation(Override.class)
      .returns(setOfClassOfWildcardOfObject);

  if (excludedClassNames.isEmpty()) {
    builder.addStatement("return $T.emptySet()", Collections.class);
  } else {
    builder.addStatement(
        "$T excludedClasses = new $T()", setOfClassOfWildcardOfObject,
        hashSetOfClassOfWildcardOfObject);
    for (String excludedClassName : excludedClassNames) {
      // TODO: Remove this when we no longer support manifest parsing.
      // Using a Literal ($L) instead of a type ($T) to get a fully qualified import that allows
      // us to suppress deprecation warnings. Aimed at deprecated GlideModules.
      builder.addStatement("excludedClasses.add($L.class)", excludedClassName);
    }
    builder.addStatement("return excludedClasses");
  }

  return builder.build();
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
private List<MethodSpec> generateConstructors() {
  ParameterizedTypeName classOfTranscodeType =
      ParameterizedTypeName.get(ClassName.get(Class.class), transcodeTypeName);

  TypeName wildcardOfObject = WildcardTypeName.subtypeOf(Object.class);
  ParameterizedTypeName requestBuilderOfWildcardOfObject =
      ParameterizedTypeName.get(ClassName.get(requestBuilderType), wildcardOfObject);

  MethodSpec firstConstructor =
      MethodSpec.constructorBuilder()
          .addParameter(classOfTranscodeType, "transcodeClass")
          .addParameter(requestBuilderOfWildcardOfObject, "other")
      .addStatement("super($N, $N)", "transcodeClass", "other")
      .build();

  ClassName context = ClassName.get("android.content", "Context");
  ClassName glide = ClassName.get("com.bumptech.glide", "Glide");
  ClassName requestManager = ClassName.get("com.bumptech.glide", "RequestManager");
  MethodSpec secondConstructor =
      MethodSpec.constructorBuilder()
          .addParameter(glide, "glide")
          .addParameter(requestManager, "requestManager")
          .addParameter(classOfTranscodeType, "transcodeClass")
          .addParameter(context, "context")
          .addStatement(
              "super($N, $N ,$N, $N)", "glide", "requestManager", "transcodeClass", "context")
          .build();
  return ImmutableList.of(firstConstructor, secondConstructor);
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
public static JavaFile statement(Domain ontology) {
	
	ClassName name = ClassName.get(ontology.getTargetPackage(), ontology.getName() + MARKER_MDC);

	ClassName markerName = MarkerGenerator.getName(ontology);
	
    TypeName wildcard = WildcardTypeName.subtypeOf(DomainMarker.class);
    TypeName classOfAny = ParameterizedTypeName.get(ClassName.get(Class.class), wildcard);
    
	ParameterSpec type = ParameterSpec.builder(classOfAny, "type").build();

	return JavaFile.builder(name.packageName(), TypeSpec.classBuilder(name)
				.superclass(ParameterizedTypeName.get( ClassName.get(DomainMdc.class), markerName))
				.addModifiers(Modifier.PUBLIC)
				.addMethod(MethodSpec.constructorBuilder()
					.addModifiers(Modifier.PUBLIC)
					.addStatement("super($T.QUALIFIER)", markerName)
					.build()
				)
				.addMethod(MethodSpec.methodBuilder("createMarker")
						.addModifiers(Modifier.PUBLIC)
						.addStatement("return new $T()", markerName)
						.returns(markerName)
						.build()
					)
				.addMethod(MethodSpec.methodBuilder("supports")
						.addModifiers(Modifier.PUBLIC)
						.addParameter(type)
						.addStatement("return $T.class == $N", markerName, type)
						.returns(boolean.class)
						.build()
					)
				.build())
			
			.build();
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
public TypeName parameterType(MemberModel memberModel) {
    if (memberModel.isList()) {
        ListModel listModel = memberModel.getListModel();
        MemberModel elementModel = listModel.getListMemberModel();
        TypeName listElementType = parameterType(elementModel);
        if (elementModel.isList()) {
            listElementType = WildcardTypeName.subtypeOf(listElementType);
        }
        return ParameterizedTypeName.get(ClassName.get(Collection.class), listElementType);
    }

    if (memberModel.isMap()) {
        MapModel mapModel = memberModel.getMapModel();

        TypeName keyType;
        if (mapModel.getKeyModel().isSimple()) {
            keyType = getTypeNameForSimpleType(mapModel.getKeyModel().getVariable().getVariableType());
        } else {
            keyType = parameterType(mapModel.getKeyModel());

        }

        TypeName valueType = parameterType(mapModel.getValueModel());
        if (mapModel.getValueModel().isList()) {
            valueType = WildcardTypeName.subtypeOf(valueType);
        }

        return ParameterizedTypeName.get(ClassName.get(Map.class), keyType, valueType);
    }

    return fieldType(memberModel);
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
public TypeName mapEntryType(MapModel mapModel) {
    TypeName keyType;
    if (mapModel.getKeyModel().isSimple()) {
        keyType = getTypeNameForSimpleType(mapModel.getKeyModel().getVariable().getVariableType());
    } else {
        keyType = parameterType(mapModel.getKeyModel());
    }

    TypeName valueType = parameterType(mapModel.getValueModel());
    if (mapModel.getValueModel().isList()) {
        valueType = WildcardTypeName.subtypeOf(valueType);
    }

    return ParameterizedTypeName.get(ClassName.get(Map.Entry.class), keyType, valueType);
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
private WildcardTypeName wildcardName( JWildcardType type ) {
    switch ( type.getBoundType() ) {
        case SUPER:
            return WildcardTypeName.supertypeOf( typeName( type.getFirstBound() ) );
        default:
            return WildcardTypeName.subtypeOf( typeName( type.getFirstBound() ) );
    }
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
public static TypeName wildcardType(TypeName upperBound) {
    return WildcardTypeName.subtypeOf(upperBound);
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
/**
 * Returns a JavaPoet {@link TypeName} representation of:
 * <ul>
 * <li>The given {@link TypeName}, if it does represent a class that is
 * eligible for substitution in this inventory; or,</li>
 * <li>The matching substitution class, based on the current output
 * class.</li>
 * </ul>
 * A substitution may be the outputClass itself, or the corresponding nested
 * class. For example, if the current output class is
 * {@code my.result.OutputCLass}, and this inventory is for the type
 * {@code my.input.Template} which has nested types
 * {@code my.input.Template.Nested} and
 * {@code my.input.Template.Nested.MoreNested}, this method would behave as
 * follows:
 * <ul>
 * <li>{@code (my.input.Template, my.result.OutputClass) => my.result.OutputClass}</li>
 * <li>{@code (my.input.Template.Nested, my.result.OutputClass) => my.result.OutputClass.Nested}</li>
 * <li>{@code (my.input.Template.Nested.MoreNested, my.result.OutputClass) => my.result.OutputClass.Nested.MoreNested}</li>
 * <li>{@code (java.lang.String, my.result.OutputClass) => java.lang.String}</li>
 * </ul>
 * 
 * @param mightBeSubstituted
 *            {@link TypeName} for the type that may get substituted.
 * @return
 */
TypeName applyTypeSubstitution(final TypeName mightBeSubstituted) {

	if (mightBeSubstituted instanceof ClassName) {
		// Attempt a raw type lookup
		if (rawTypeNameSubstitutions.containsKey(mightBeSubstituted)) {
			return rawTypeNameSubstitutions.get(mightBeSubstituted);
		}

		return mightBeSubstituted;
	}

	// Type with parameters
	if (mightBeSubstituted instanceof ParameterizedTypeName) {
		final ParameterizedTypeName parameterized = (ParameterizedTypeName)mightBeSubstituted;

		// Recurse for raw type and type parameters
		final ClassName rawType = (ClassName)applyTypeSubstitution(parameterized.rawType);
		final TypeName[] typeArgs = new TypeName[parameterized.typeArguments.size()];
		for (int i = 0; i < parameterized.typeArguments.size(); i++) {
			typeArgs[i] = applyTypeSubstitution(parameterized.typeArguments.get(i));
		}

		return ParameterizedTypeName.get(rawType, typeArgs);
	}

	// Wildcard type
	if (mightBeSubstituted instanceof WildcardTypeName) {
		final WildcardTypeName wildcard = (WildcardTypeName)mightBeSubstituted;

		// Recurse on bounds
		// JavaPoet Wildcard types always have an upper bound. The absence/presence
		// of a lower bound determines if this is an "extends" or "super". See
		// validations in private constructor and usage in emit()

		if (wildcard.lowerBounds.size() == 1) {
			return WildcardTypeName.supertypeOf(
					applyTypeSubstitution(wildcard.lowerBounds.get(0)));
		} else {
			return WildcardTypeName.subtypeOf(
					applyTypeSubstitution(wildcard.upperBounds.get(0)));
		}
	}

	return mightBeSubstituted;
}
 

import com.squareup.javapoet.WildcardTypeName; //导入方法依赖的package包/类
public static WildcardTypeName anyWildcardTypeName() {
  return WildcardTypeName.subtypeOf(Object.class);
}