/** * Returns the final {@link ClassOrInterfaceType} from a {@link Type} * * @param initType * @return the final {@link ClassOrInterfaceType} or null if no * {@link ClassOrInterfaceType} found */ public static ClassOrInterfaceType getClassOrInterfaceType(final Type type) { Type tmp = type; while (tmp instanceof ReferenceType) { tmp = ((ReferenceType) tmp).getType(); } if (tmp instanceof ClassOrInterfaceType) { return (ClassOrInterfaceType) tmp; } return null; } }
final ClassOrInterfaceType cType = (ClassOrInterfaceType) type; final ClassOrInterfaceType cType2 = (ClassOrInterfaceType) type2; return cType.getName().equals(cType2.getName()); return pType.getType() == pType2.getType(); final WildcardType wType = (WildcardType) type; final WildcardType wType2 = (WildcardType) type2; return equals(wType.getSuper(), wType2.getSuper()) && equals(wType.getExtends(), wType2.getExtends());
/** * Converts the indicated {@link JavaType} into a {@link ReferenceType}. * <p> * Note that no effort is made to manage imports etc. * * @param nameExpr to convert (required) * @return the corresponding {@link ReferenceType} (never null) */ public static ReferenceType getReferenceType(final NameExpr nameExpr) { Validate.notNull(nameExpr, "Java type required"); return new ReferenceType(getClassOrInterfaceType(nameExpr)); }
array = ((ReferenceType) internalType).getArrayCount(); if (array > 0) { internalType = ((ReferenceType) internalType).getType(); if (pt.getType().equals(Primitive.Boolean)) { return new JavaType(Boolean.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Char)) { return new JavaType(Character.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Byte)) { return new JavaType(Byte.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Short)) { return new JavaType(Short.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Int)) { return new JavaType(Integer.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Long)) { return new JavaType(Long.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Float)) { return new JavaType(Float.class.getName(), array, DataType.PRIMITIVE, null, null); if (pt.getType().equals(Primitive.Double)) { return new JavaType(Double.class.getName(), array, DataType.PRIMITIVE, null, null); throw new IllegalStateException("Unsupported primitive '" + pt.getType() + "'");
public Node visit(WildcardType n, A arg) { if (n.getExtends() != null) { n.setExtends((ReferenceType) n.getExtends().accept(this, arg)); } if (n.getSuper() != null) { n.setSuper((ReferenceType) n.getSuper().accept(this, arg)); } return n; }
public R visit(WildcardType n, A arg) { if (n.getExtends() != null) { n.getExtends().accept(this, arg); } if (n.getSuper() != null) { n.getSuper().accept(this, arg); } return null; }
public void visit(ClassOrInterfaceType n, A arg) { if (n.getScope() != null) { n.getScope().accept(this, arg); } if (n.getTypeArgs() != null) { for (Type t : n.getTypeArgs()) { t.accept(this, arg); } } }
final Type type = ((ClassExpr) value).getType(); if (type instanceof ClassOrInterfaceType) { final JavaType javaType = new JavaType(((ClassOrInterfaceType) type).getName()); final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType); if (!(nameToUse instanceof QualifiedNameExpr)) { return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName())); && ((ReferenceType) type).getType() instanceof ClassOrInterfaceType) { final ClassOrInterfaceType cit = (ClassOrInterfaceType) ((ReferenceType) type).getType(); final JavaType javaType = new JavaType(cit.getName()); final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType); if (!(nameToUse instanceof QualifiedNameExpr)) { return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName()));
final ReferenceType rt = new ReferenceType(); rt.setArrayCount(method.getReturnType().getArray()); rt.setType(returnType); returnType = rt; cit.setTypeArgs(typeArgs); for (final JavaType parameter : method.getReturnType().getParameters()) { typeArgs.add(JavaParserUtils.importParametersForType( final ReferenceType rt = new ReferenceType(); rt.setArrayCount(method.getReturnType().getArray()); rt.setType(cit); returnType = rt; } else { final ReferenceType rt = new ReferenceType(); rt.setArrayCount(methodParameter.getJavaType().getArray()); rt.setType(parameterType); parameterType = rt; cit.setTypeArgs(typeArgs); for (final JavaType parameter : methodParameter.getJavaType().getParameters()) { typeArgs.add(JavaParserUtils.importParametersForType( final ReferenceType rt = new ReferenceType(); rt.setArrayCount(methodParameter.getJavaType().getArray()); rt.setType(cit); parameterType = rt; } else {
Validate.notNull(compilationUnitPackage, "Compilation unit package required"); String typeName = cit.getName(); ClassOrInterfaceType scope = cit.getScope(); while (scope != null) { typeName = scope.getName() + "." + typeName; scope = scope.getScope(); if (cit.getTypeArgs() != null) { for (final Type ta : cit.getTypeArgs()) { parameterTypes.add(getJavaType(compilationUnitServices, ta, typeParameters));
public static ReferenceType importParametersForType(final JavaType targetType, final List<ImportDeclaration> imports, final JavaType typeToImport) { Validate.notNull(targetType, "Target type is required"); Validate.notNull(imports, "Compilation unit imports required"); Validate.notNull(typeToImport, "Java type to import is required"); final ClassOrInterfaceType cit = getClassOrInterfaceType(importTypeIfRequired(targetType, imports, typeToImport)); // Add any type arguments presented for the return type if (typeToImport.getParameters().size() > 0) { final List<Type> typeArgs = new ArrayList<Type>(); cit.setTypeArgs(typeArgs); for (final JavaType parameter : typeToImport.getParameters()) { typeArgs.add(JavaParserUtils.importParametersForType(targetType, imports, parameter)); } } final ReferenceType refType = new ReferenceType(cit); // Handle arrays if (typeToImport.isArray()) { refType.setArrayCount(typeToImport.getArray()); } return refType; }
public static Type getResolvedName(final JavaType target, final JavaType current, final CompilationUnitServices compilationUnit) { final NameExpr nameExpr = JavaParserUtils.importTypeIfRequired(target, compilationUnit.getImports(), current); final ClassOrInterfaceType resolvedName = JavaParserUtils.getClassOrInterfaceType(nameExpr); if (current.getParameters() != null && current.getParameters().size() > 0) { resolvedName.setTypeArgs(new ArrayList<Type>()); for (final JavaType param : current.getParameters()) { resolvedName.getTypeArgs().add(getResolvedName(target, param, compilationUnit)); } } if (current.getArray() > 0) { // Primitives includes array declaration in resolvedName if (!current.isPrimitive()) { return new ReferenceType(resolvedName, current.getArray()); } } return resolvedName; }
return new VoidType(); } else if (typeName.equals(JavaType.BOOLEAN_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Boolean); } else if (typeName.equals(JavaType.BYTE_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Byte); } else if (typeName.equals(JavaType.CHAR_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Char); } else if (typeName.equals(JavaType.DOUBLE_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Double); } else if (typeName.equals(JavaType.FLOAT_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Float); } else if (typeName.equals(JavaType.INT_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Int); } else if (typeName.equals(JavaType.LONG_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Long); } else if (typeName.equals(JavaType.SHORT_PRIMITIVE.getFullyQualifiedTypeName())) { return new PrimitiveType(Primitive.Short);
public static ClassOrInterfaceType getResolvedName(final JavaType target, final JavaType current, final CompilationUnit compilationUnit) { final NameExpr nameExpr = JavaParserUtils.importTypeIfRequired(target, compilationUnit.getImports(), current); final ClassOrInterfaceType resolvedName = JavaParserUtils.getClassOrInterfaceType(nameExpr); if (current.getParameters() != null && current.getParameters().size() > 0) { resolvedName.setTypeArgs(new ArrayList<Type>()); for (final JavaType param : current.getParameters()) { resolvedName.getTypeArgs().add(getResolvedName(target, param, compilationUnit)); } } return resolvedName; }
/** * Creates a new {@link ReferenceType} for a class or interface. * * @param name * name of the class or interface * @param arrayCount * number os arrays or <code>0</code> if is not a array. * @return instanceof {@link ReferenceType} */ public static ReferenceType createReferenceType(String name, int arrayCount) { return new ReferenceType(new ClassOrInterfaceType(name), arrayCount); }
/** * Converts the indicated {@link NameExpr} into a * {@link ClassOrInterfaceType}. * <p> * Note that no effort is made to manage imports etc. * * @param nameExpr to convert (required) * @return the corresponding {@link ClassOrInterfaceType} (never null) */ public static ClassOrInterfaceType getClassOrInterfaceType(final NameExpr nameExpr) { Validate.notNull(nameExpr, "Java type required"); if (nameExpr instanceof QualifiedNameExpr) { final QualifiedNameExpr qne = (QualifiedNameExpr) nameExpr; if (StringUtils.isNotBlank(qne.getQualifier().getName())) { return new ClassOrInterfaceType(qne.getQualifier().getName() + "." + qne.getName()); } return new ClassOrInterfaceType(qne.getName()); } return new ClassOrInterfaceType(nameExpr.getName()); }
public Node visit(WildcardType n, A arg) { if (n.getExtends() != null) { n.setExtends((ReferenceType) n.getExtends().accept(this, arg)); } if (n.getSuper() != null) { n.setSuper((ReferenceType) n.getSuper().accept(this, arg)); } return n; }
public void visit(WildcardType n, A arg) { if (n.getExtends() != null) { n.getExtends().accept(this, arg); } if (n.getSuper() != null) { n.getSuper().accept(this, arg); } } }
public R visit(ClassOrInterfaceType n, A arg) { if (n.getScope() != null) { n.getScope().accept(this, arg); } if (n.getTypeArgs() != null) { for (Type t : n.getTypeArgs()) { t.accept(this, arg); } } return null; }
public void visit(WildcardType n, A arg) { if (n.getExtends() != null) { n.getExtends().accept(this, arg); } if (n.getSuper() != null) { n.getSuper().accept(this, arg); } } }