下面列出了怎么用org.eclipse.jdt.core.dom.QualifiedType的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* For {@link Name} or {@link Type} nodes, returns the topmost {@link Type} node
* that shares the same type binding as the given node.
*
* @param node an ASTNode
* @return the normalized {@link Type} node or the original node
*/
public static ASTNode getNormalizedNode(ASTNode node) {
ASTNode current= node;
// normalize name
if (QualifiedName.NAME_PROPERTY.equals(current.getLocationInParent())) {
current= current.getParent();
}
// normalize type
if (QualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())
|| SimpleType.NAME_PROPERTY.equals(current.getLocationInParent())
|| NameQualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())) {
current= current.getParent();
}
// normalize parameterized types
if (ParameterizedType.TYPE_PROPERTY.equals(current.getLocationInParent())) {
current= current.getParent();
}
return current;
}
private static boolean isQualifiedType(Type type) {
if(type instanceof SimpleType) {
SimpleType simpleType = (SimpleType)type;
Name name = simpleType.getName();
if(name instanceof QualifiedName) {
return true;
}
}
else if(type instanceof QualifiedType) {
QualifiedType qualifiedType = (QualifiedType)type;
Type qualifier = qualifiedType.getQualifier();
return isQualifiedType(qualifier);
}
else if(type instanceof ArrayType) {
ArrayType arrayType = (ArrayType)type;
Type elementType = arrayType.getElementType();
return isQualifiedType(elementType);
}
else if(type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType)type;
Type erasureType = parameterizedType.getType();
return isQualifiedType(erasureType);
}
return false;
}
@Override
public boolean visit(QualifiedType node) {
addType(
node.resolveBinding(),
extractClassNameFromQualifiedName(extractTypeNameWithoutGenerics(node)),
node.getStartPosition());
return true;
}
/**
* @return a String representation of 'type'. Handles qualified, simple and parameterized types.
*/
@Nullable
private String getNameOfType(Type type) {
if (type instanceof QualifiedType) {
return extractTypeNameWithoutGenerics((QualifiedType) type);
}
if (type instanceof SimpleType) {
return ((SimpleType) type).getName().getFullyQualifiedName();
}
if (type instanceof ParameterizedType) {
return getNameOfType(((ParameterizedType) type).getType());
}
return null;
}
@Test
public void testExtractTypeNameWithoutGenerics() {
AST ast = AST.newAST(AST.JLS4);
org.eclipse.jdt.core.dom.SimpleName entry = ast.newSimpleName("Entry");
ParameterizedType map = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Map")));
map.typeArguments().add(ast.newSimpleType(ast.newSimpleName("Foo")));
QualifiedType type = ast.newQualifiedType(map, entry);
assertThat(type.toString()).isEqualTo("Map<Foo>.Entry");
assertThat(ReferencedClassesParser.extractTypeNameWithoutGenerics(type)).isEqualTo("Map.Entry");
}
private TypeLiteral createBuilderClassReferenceLiteral(AST ast, CompilationUnitModificationDomain compilationUnitModificationDomain, TypeDeclaration builderType) {
String originalClassName = compilationUnitModificationDomain.getOriginalType().getName().toString();
String builderClassName = builderType.getName().toString();
QualifiedType qualifiedType = ast.newQualifiedType(ast.newSimpleType(ast.newSimpleName(originalClassName)), ast.newSimpleName(builderClassName));
TypeLiteral typeLiteral = ast.newTypeLiteral();
typeLiteral.setType(qualifiedType);
return typeLiteral;
}
@Override
public void endVisit(QualifiedType node) {
if (skipNode(node)) {
return;
}
processSequential(node, node.getQualifier(), node.getName());
}
private static String getPrettyTypeName(Type type) {
if (type.isArrayType()) {
return getPrettyTypeName((ArrayType) type);
} else if (type.isParameterizedType()) {
return getPrettyTypeName((ParameterizedType) type);
} else if (type.isPrimitiveType()) {
return getPrettyTypeName((PrimitiveType) type);
} else if (type.isQualifiedType()) {
return getPrettyTypeName((QualifiedType) type);
} else if (type.isSimpleType()) {
return getPrettyTypeName((SimpleType) type);
} else {
return "";
}
}
@Override
public boolean visit(final QualifiedType node) {
node.getQualifier().accept(this);
this.appendToBuffer(".");
node.getName().accept(this);
return false;
}
public boolean visit(QualifiedType node) {
types.add(node.toString());
if(current.getUserObject() != null) {
AnonymousClassDeclarationObject anonymous = (AnonymousClassDeclarationObject)current.getUserObject();
anonymous.getTypes().add(node.toString());
}
return false;
}
private void handleType(Type type) {
if (type instanceof PrimitiveType) {
visit((PrimitiveType) type);
} else if (type instanceof ArrayType) {
visit((ArrayType) type);
} else if (type instanceof SimpleType) {
visit((SimpleType) type);
} else if (type instanceof QualifiedType) {
visit((QualifiedType) type);
} else if (type instanceof ParameterizedType) {
visit((ParameterizedType) type);
} else if (type instanceof WildcardType) {
visit((WildcardType) type);
}
}
public boolean visit(QualifiedType type) {
/*
* QualifiedType: Type . SimpleName
*/
activateDiffStyle(type);
handleType(type.getQualifier());
appendPeriod();
handleExpression(type.getName());
deactivateDiffStyle(type);
return false;
}
private void handleType(Type type) {
if (type instanceof PrimitiveType) {
visit((PrimitiveType) type);
} else if (type instanceof ArrayType) {
visit((ArrayType) type);
} else if (type instanceof SimpleType) {
visit((SimpleType) type);
} else if (type instanceof QualifiedType) {
visit((QualifiedType) type);
} else if (type instanceof ParameterizedType) {
visit((ParameterizedType) type);
} else if (type instanceof WildcardType) {
visit((WildcardType) type);
}
}
private static String getPrettyTypeName(QualifiedType type) {
return type.resolveBinding().getQualifiedName();
}
@Override
public boolean visit(final QualifiedType node) {
Assert.isNotNull(node);
return false;
}
@Override
public void endVisit(QualifiedType node) {
if (skipNode(node))
return;
processSequential(node, node.getQualifier(), node.getName());
}
@Override
public boolean visit(QualifiedType node) {
if (node.subtreeMatch(fMatcher, fNodeToMatch))
return matches(node);
return super.visit(node);
}
@Override
public void endVisit(QualifiedType node) {
endVisitNode(node);
}
@Override
public boolean visit(QualifiedType node) {
return visitNode(node);
}
@Override
public boolean visit(QualifiedType node) {
doVisitNode(node.getQualifier());
visitAnnotations(node);
return false;
}
private static void getFullyQualifiedName(Type type, StringBuffer buffer) {
switch (type.getNodeType()) {
case ASTNode.ARRAY_TYPE:
ArrayType arrayType = (ArrayType) type;
getFullyQualifiedName(arrayType.getElementType(), buffer);
for (int i = 0, length = arrayType.getDimensions(); i < length; i++) {
buffer.append('[');
buffer.append(']');
}
break;
case ASTNode.PARAMETERIZED_TYPE:
ParameterizedType parameterizedType = (ParameterizedType) type;
getFullyQualifiedName(parameterizedType.getType(), buffer);
buffer.append('<');
Iterator iterator = parameterizedType.typeArguments().iterator();
boolean isFirst = true;
while (iterator.hasNext()) {
if (!isFirst)
buffer.append(',');
else
isFirst = false;
Type typeArgument = (Type) iterator.next();
getFullyQualifiedName(typeArgument, buffer);
}
buffer.append('>');
break;
case ASTNode.PRIMITIVE_TYPE:
buffer.append(((PrimitiveType) type).getPrimitiveTypeCode().toString());
break;
case ASTNode.QUALIFIED_TYPE:
buffer.append(((QualifiedType) type).getName().getFullyQualifiedName());
break;
case ASTNode.SIMPLE_TYPE:
buffer.append(((SimpleType) type).getName().getFullyQualifiedName());
break;
case ASTNode.WILDCARD_TYPE:
buffer.append('?');
WildcardType wildcardType = (WildcardType) type;
Type bound = wildcardType.getBound();
if (bound == null) return;
if (wildcardType.isUpperBound()) {
buffer.append(" extends "); //$NON-NLS-1$
} else {
buffer.append(" super "); //$NON-NLS-1$
}
getFullyQualifiedName(bound, buffer);
break;
}
}
public boolean visit(QualifiedType type) {
handleType(type.getQualifier());
handleExpression(type.getName());
return false;
}