if ( converterDefinedType.getTypeParameters().isEmpty() ) { return true; if ( checkType.getTypeParameters().isEmpty() ) { if ( converterDefinedType.getTypeParameters().size() != checkType.getTypeParameters().size() ) { for ( int i = 0; i < converterDefinedType.getTypeParameters().size(); i++ ) { if ( !typesMatch( converterDefinedType.getTypeParameters().get( i ), checkType.getTypeParameters().get( i ) ) ) { return false;
/** * Method that will try to find type parameterization this type * has for specified super type * * @return List of type parameters for specified supertype (which may * be empty, if supertype is not a parametric type); null if specified * type is not a super type of this type */ public List<ResolvedType> typeParametersFor(Class<?> erasedSupertype) { ResolvedType type = findSupertype(erasedSupertype); if (type != null) { return type.getTypeParameters(); } // nope; doesn't look like we extend or implement super type in question return null; }
/** * Method that will try to find type parameterization this type * has for specified super type * * @return List of type parameters for specified supertype (which may * be empty, if supertype is not a parametric type); null if specified * type is not a super type of this type */ public List<ResolvedType> typeParametersFor(Class<?> erasedSupertype) { ResolvedType type = findSupertype(erasedSupertype); if (type != null) { return type.getTypeParameters(); } // nope; doesn't look like we extend or implement super type in question return null; }
private List<? extends ResolvedType> resolvedTypeParameters(ModelContext modelContext, ResolvedType resolvedType) { List<ResolvedType> parameters = newArrayList(); for (ResolvedType parameter : resolvedType.getTypeParameters()) { parameters.add(alternateTypeProvider.alternateFor(parameter)); parameters.addAll(resolvedDependencies(ModelContext.fromParent(modelContext, parameter))); } return parameters; }
private List<? extends ResolvedType> resolvedTypeParameters(ModelContext modelContext, ResolvedType resolvedType) { List<ResolvedType> parameters = newArrayList(); for (ResolvedType parameter : resolvedType.getTypeParameters()) { parameters.add(modelContext.alternateFor(parameter)); parameters.addAll(resolvedDependencies(fromParent(modelContext, parameter))); } return parameters; }
private List<? extends ResolvedType> resolvedTypeParameters(ModelContext modelContext, ResolvedType resolvedType) { List<ResolvedType> parameters = newArrayList(); for (ResolvedType parameter : resolvedType.getTypeParameters()) { parameters.add(alternateTypeProvider.alternateFor(parameter)); parameters.addAll(resolvedDependencies(ModelContext.fromParent(modelContext, parameter))); } return parameters; }
/** * Method only used by test code: do not use otherwise. */ protected void _addForTest(ResolvedType type) { List<ResolvedType> tp = type.getTypeParameters(); ResolvedType[] tpa = tp.toArray(new ResolvedType[tp.size()]); put(key(type.getErasedType(), tpa), type); } }
private static String innerTypeName(ResolvedType type) { if (type.getTypeParameters().size() > 0 && type.getErasedType().getTypeParameters().length > 0) { return genericTypeName(type); } return simpleTypeName(type); }
/** * Method only used by test code: do not use otherwise. */ protected void _addForTest(ResolvedType type) { List<ResolvedType> tp = type.getTypeParameters(); ResolvedType[] tpa = tp.toArray(new ResolvedType[tp.size()]); put(key(type.getErasedType(), tpa), type); } }
private String innerTypeName(ResolvedType type, DocumentationType documentationType) { if (type.getTypeParameters().size() > 0 && type.getErasedType().getTypeParameters().length > 0) { return genericTypeName(type, documentationType); } return simpleTypeName(type, documentationType); }
private static String optionalContainerTypeQualifierForReturn(ResolvedType type) { if (type.isArray()) { return String.format("[%s]", typeName(type.getArrayElementType())); } List<ResolvedType> typeParameters = type.getTypeParameters(); checkArgument(typeParameters.size() <= 1, "Expects container to have at most one generic parameter"); if (typeParameters.size() == 0) { return ""; } String qualifier = innerTypeName(typeParameters.get(0)); if (Types.isBaseType(qualifier)) { return ""; } return String.format("[%s]", qualifier); }
/** * This method transforms a Java object into a Bali node. * * @param <T> the generic type of the java object to transform. * @param object The java object to be transformed. * @param genericType The generic type of the object * @return The Bali node corresponding to the Java object. */ public <T> ComponentNode fromObject(T object, GenericType<T> genericType) { ResolvedType resolvedType = typeResolver.resolve(genericType); List<ResolvedType> resolvedTypeParameters = resolvedType.getTypeParameters(); Class<?>[] parameterTypes = new Class<?>[resolvedTypeParameters.size()]; for (int i = 0; i < parameterTypes.length; i++) { parameterTypes[i] = resolvedTypeParameters.get(i).getErasedType(); } return fromObject(object, parameterTypes); }
private static String innerTypeName(ResolvedType type) { if (type.getTypeParameters().size() > 0 && type.getErasedType().getTypeParameters().length > 0) { return genericTypeName(type); } return apiModelValue(type.getErasedType()).or(simpleTypeName(type)); }
private static String optionalContainerTypeQualifierForReturn(ResolvedType type) { if (type.isArray()) { if ("object".equals(typeName(type.getArrayElementType()))) { return ""; } return String.format("[%s]", typeName(type.getArrayElementType())); } List<ResolvedType> typeParameters = type.getTypeParameters(); checkArgument(typeParameters.size() <= 1, "Expects container to have at most one generic parameter"); if (typeParameters.size() == 0) { return ""; } String qualifier = innerTypeName(typeParameters.get(0)); if ("object".equals(qualifier)) { return ""; } return String.format("[%s]", qualifier); }
/** * This method constructs a Java object from Bali code. * * @param <T> the concreteClass type that will be returned * @param componentNode The root Bali parse tree node. * @param genericType The generic type of the object * @return The Java object. */ public <T> T toObject(ComponentNode componentNode, GenericType<T> genericType) { ResolvedType resolvedType = typeResolver.resolve(genericType); List<ResolvedType> resolvedTypeParameters = resolvedType.getTypeParameters(); Class<?>[] parameterTypes = new Class<?>[resolvedTypeParameters.size()]; for (int i = 0; i < parameterTypes.length; i++) { parameterTypes[i] = resolvedTypeParameters.get(i).getErasedType(); } return toObject(componentNode, resolvedType.getErasedType(), parameterTypes); }
private String genericTypeName(ResolvedType resolvedType, DocumentationType documentationType) { Class<?> erasedType = resolvedType.getErasedType(); ModelNameContext nameContext = new ModelNameContext(resolvedType.getErasedType(), documentationType); String simpleName = fromNullable(typeNameFor(erasedType)).or(pluginsManager.typeName(nameContext)); StringBuilder sb = new StringBuilder(String.format("%s%s", simpleName, namingStrategy.getOpenGeneric())); boolean first = true; for (int index = 0; index < erasedType.getTypeParameters().length; index++) { ResolvedType typeParam = resolvedType.getTypeParameters().get(index); if (first) { sb.append(innerTypeName(typeParam, documentationType)); first = false; } else { sb.append(String.format("%s%s", namingStrategy.getTypeListDelimiter(), innerTypeName(typeParam, documentationType))); } } sb.append(namingStrategy.getCloseGeneric()); return sb.toString(); }
private void setQualifiedTypeName() { if (getType().getTypeParameters().size() > 0) { this.qualifiedTypeName = getType().toString(); return; } this.qualifiedTypeName = simpleQualifiedTypeName(getType()); }
@Override public String qualifiedTypeName() { if (getType().getTypeParameters().size() > 0) { return getType().toString(); } return ResolvedTypes.simpleQualifiedTypeName(getType()); }
@Override public String qualifiedTypeName() { if (getType().getTypeParameters().size() > 0) { return getType().toString(); } return simpleQualifiedTypeName(getType()); }
@Override public String qualifiedTypeName() { if (getType().getTypeParameters().size() > 0) { return getType().toString(); } return simpleQualifiedTypeName(getType()); }