Java ClassOrInterfaceType类代码示例

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Override
protected String getTypeName(CompilationUnit compilationUnit, int index) {
    ClassOrInterfaceDeclaration type = (ClassOrInterfaceDeclaration) compilationUnit.getType(0);
    NodeList<ClassOrInterfaceType> extendedTypes = type.getExtendedTypes();
    ClassOrInterfaceType extendedType = extendedTypes.get(index);
    String typeSimpleName = extendedType.getName().getIdentifier();
    Optional<ClassOrInterfaceType> scope = extendedType.getScope();
    String typeName;
    if (scope.isPresent()) {
        String typePackageName = scope.get().toString();
        typeName = String.format("%s.%s", typePackageName, typeSimpleName);
    } else {
        typeName = typeSimpleName;
    }
    return typeName;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Nullable
Class<?> typeOf( Type type ) {
    if ( type instanceof ReferenceType ) {
        ReferenceType referenceType = ( ReferenceType ) type;
        if ( referenceType.getArrayCount() > 0 ) {
            return Array.class;
        }
        // unwrap the reference type and try again
        return typeOf( referenceType.getType() );
    }

    if ( type instanceof PrimitiveType ) {
        String typeName = ( ( PrimitiveType ) type ).getType().name();
        return primitiveType( typeName );
    } else if ( type instanceof ClassOrInterfaceType ) try {
        return classForName( ( ( ClassOrInterfaceType ) type ).getName() );
    } catch ( ClassNotFoundException e ) {
        // class not found, ignore
    }

    return null;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public void calculate(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, CompilationUnit compilationUnit) {
    List<ClassOrInterfaceType> implementedInterfaces = classOrInterfaceDeclaration.getImplementedTypes();
    for (ClassOrInterfaceType implementedInterface : implementedInterfaces) {
        String implementedInterfaceName = implementedInterface.getNameAsString();
        String implementedInterfacePackageName = implementedInterface
                .findCompilationUnit()
                .flatMap(CompilationUnit::getPackageDeclaration)
                .flatMap(pkg -> Optional.of(pkg.getNameAsString())).orElse("???");
        if (typeDao.exist(implementedInterfaceName, implementedInterfacePackageName)) { // JDK interfaces are not indexed
            int interfaceId = typeDao.getId(implementedInterfaceName, implementedInterfacePackageName);
            String cuPackageName = compilationUnit.getPackageDeclaration().get().getNameAsString();
            int nbClasses = typeDao.count(classOrInterfaceDeclaration.getNameAsString(), cuPackageName);
            if (nbClasses > 1) {
                System.err.println("More than one class having the same name '" + classOrInterfaceDeclaration.getName() + "' and package '" + cuPackageName + "'");
            } else {
                int classId = typeDao.getId(classOrInterfaceDeclaration.getNameAsString(), cuPackageName);
                implementsDao.save(new Implements(classId, interfaceId));
            }
        }
    }
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public void calculate(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, CompilationUnit compilationUnit) {
    List<ClassOrInterfaceType> extendedTypes = classOrInterfaceDeclaration.getExtendedTypes();
    for (ClassOrInterfaceType extendedType : extendedTypes) {
        String extendedTypeName = extendedType.getNameAsString();
        String extendedTypePackageName = extendedType
                .findCompilationUnit()
                .flatMap(CompilationUnit::getPackageDeclaration)
                .flatMap(pkg -> Optional.of(pkg.getNameAsString())).orElse("???");

        if (typeDao.exist(extendedTypeName, extendedTypePackageName)) { // JDK interfaces are not indexed
            int extendedInterfaceId = typeDao.getId(extendedTypeName, extendedTypePackageName);
            int interfaceId = typeDao.getId(classOrInterfaceDeclaration.getNameAsString(), compilationUnit.getPackageDeclaration().get().getNameAsString());
            extendsDao.save(new Extends(interfaceId, extendedInterfaceId));
        }
    }
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
private void generateFakeRelation(String fk) throws Exception {
	DbTable parent = g().findTableByNames(null, fk);
	if(null == parent) {
		g().error(this + ": user specified FK specifies unknown table '" + fk + "'");
		return;
	}

	ClassWrapper parentClass = g().findClassByTable(parent);
	if(null == parentClass) {
		g().error("Cannot locate class source file for " + parent + ", mapping as non-relation");
		calculateBasicType();
		return;
	}

	ClassOrInterfaceType referent = new ClassOrInterfaceType(parentClass.getClassName());
	setPropertyType(referent);
	setManyToOne(parentClass);
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public void resolveManyToOne() {
	if(getRelationType() != RelationType.manyToOne)
		return;

	ClassOrInterfaceType ct = (ClassOrInterfaceType) getPropertyType();
	String parentClassName = ct.getName().asString();
	parentClassName = m_classWrapper.tryResolveFullName(parentClassName);

	ClassWrapper parentClass = g().findClassWrapper(m_classWrapper.getPackageName(), parentClassName);
	if(null == parentClass) {
		m_classWrapper.error(this + ": cannot locate class " + parentClassName + " inside parsed entities");
		return;
	} else {
		m_parentClass = parentClass;
	}
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public void changePropertyType(ClassOrInterfaceType newType) {
	VariableDeclarator vd = getVariableDeclaration();
	if(null != vd) {
		vd.setType(newType);
	}

	MethodDeclaration getter = getGetter();
	if(null != getter) {
		getter.setType(newType);
	}

	MethodDeclaration setter = getSetter();
	if(null != setter) {
		setter.getParameter(0).setType(newType);
	}
	m_propertyType = newType;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Override
public final void visit(ClassOrInterfaceType ctx, Object arg) {

    if (!componentStack.isEmpty()) {
        final Component currCmp = componentStack.peek();
        currCmp.insertComponentInvocation(new TypeDeclaration(resolveType(ctx.asClassOrInterfaceType().getNameAsString())));
        List<Type> typeArguments = new ArrayList<>();
        if (ctx.getTypeArguments().isPresent()) {
            typeArguments.addAll(ctx.getTypeArguments().get());
            for (Type typeArg : typeArguments) {
                if (typeArg.isClassOrInterfaceType()) {
                    if (((ClassOrInterfaceType) typeArg).getTypeArguments().isPresent()) {
                        visit(((ClassOrInterfaceType) typeArg), arg);
                    } else {
                        currCmp.insertComponentInvocation(new TypeDeclaration(resolveType(typeArg.asClassOrInterfaceType().getNameAsString())));
                    }
                } else {
                    currCmp.insertComponentInvocation(new TypeDeclaration(resolveType(typeArg.asString())));
                }
            }
        }
    }
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Override
public void visit(final ClassOrInterfaceType n, final Object arg) {
    printer.printLn("ClassOrInterfaceType");
    printJavaComment(n.getComment(), arg);

    if (n.getAnnotations() != null) {
        for (AnnotationExpr ae : n.getAnnotations()) {
            ae.accept(this, arg);
            printer.print(" ");
        }
    }

    if (n.getScope() != null) {
        n.getScope().accept(this, arg);
        printer.print(".");
    }
    printer.print(n.getName());
    printTypeArgs(n.getTypeArgs(), arg);
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Override
public boolean doIsEquals(TypeParameter first, TypeParameter second) {

    if(!StringUtils.equals(first.getName(),second.getName())) return false;

    List<ClassOrInterfaceType> firstTypeBounds = first.getTypeBound();
    List<ClassOrInterfaceType> secondTypeBounds = second.getTypeBound();

    if(firstTypeBounds == null) return secondTypeBounds == null;
    if(secondTypeBounds == null) return false;

    if(firstTypeBounds.size() != secondTypeBounds.size()) return false;

    AbstractMerger<ClassOrInterfaceType> merger = getMerger(ClassOrInterfaceType.class);

    for(int i = 0; i < firstTypeBounds.size(); i++){
        if(!merger.isEquals(firstTypeBounds.get(i),secondTypeBounds.get(i))){
            return false;
        }
    }

    return true;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public TypeRef apply(Type type) {
    if (type instanceof VoidType) {
        return new VoidRef();
    } else if (type instanceof WildcardType) {
        return new WildcardRef();
    } else if (type instanceof ReferenceType) {
        ReferenceType referenceType = (ReferenceType) type;
        int dimensions = referenceType.getArrayCount();
        TypeRef typeRef = TYPEREF.apply(referenceType.getType());
        if (dimensions == 0) {
            return typeRef;
        } else if (typeRef instanceof ClassRef) {
            return new ClassRefBuilder((ClassRef)typeRef).withDimensions(dimensions).build();
        } else if (typeRef instanceof PrimitiveRef) {
            return new PrimitiveRefBuilder((PrimitiveRef)typeRef).withDimensions(dimensions).build();
        } else if (typeRef instanceof TypeParamRef) {
            return new TypeParamRefBuilder((TypeParamRef)typeRef).withDimensions(dimensions).build();
        }
    } else if (type instanceof PrimitiveType) {
        PrimitiveType primitiveType = (PrimitiveType) type;
        return new PrimitiveRefBuilder().withName(primitiveType.getType().name()).build();
    } else if (type instanceof ClassOrInterfaceType) {
        return CLASS_OR_TYPEPARAM_REF.apply((ClassOrInterfaceType) type);
    }
    throw new IllegalArgumentException("Can't handle type:[" + type + "].");
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
private String replaceType(String typeString, Node type, Map<String, String> scanedNames, Set<String> scanedImputs,
							Map<String, Pattern> scanedRefeWrap) {
	//!!!!!String ,Object ,Integer
	if (!commonsTypes.contains(typeString)) {
		String result;
		if (hasLength(result = hasScanedTypeName(typeString, scanedNames, scanedImputs))) {
			Utils.InvokedMethod(type, "setType", new ClassOrInterfaceType(java_lang_Object));
			return result;
		}
		else {
			String theScanName = containsInPattern(scanedRefeWrap, typeString);
			if (Utils.hasLength(theScanName)) {
				StringBuilder sb = new StringBuilder(100);
				Utils.replaceWholeWord(sb, 0, typeString, theScanName, java_lang_Object);
				Utils.InvokedMethod(type, "setType", new ClassOrInterfaceType(sb.toString()));
			}
		}
	}
	return null;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
@Override
public List<ResolvedReferenceType> getAncestors() {
    List<ResolvedReferenceType> ancestors = new ArrayList<>();
    ResolvedReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType();
    ResolvedTypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0);
    enumClass = enumClass.deriveTypeParameters(new ResolvedTypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build());
    ancestors.add(enumClass);
    if (wrappedNode.getImplementedTypes() != null) {
        for (ClassOrInterfaceType implementedType : wrappedNode.getImplementedTypes()) {
            SymbolReference<ResolvedTypeDeclaration> implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId());
            if (!implementedDeclRef.isSolved()) {
                throw new UnsolvedSymbolException(implementedType.getName().getId());
            }
            ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver));
        }
    }
    return ancestors;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
public static ClassOrInterfaceType getResolvedName(final JavaType target,
        final JavaType current, final com.github.javaparser.ast.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;
}
 

import com.github.javaparser.ast.type.ClassOrInterfaceType; //导入依赖的package包/类
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));
        }
    }
    return  new ReferenceType(cit);
}