Java ElementKind.CLASS属性代码示例

/**
 * 处理每一个TypeElement
 *
 * @param unitModels      保存DUnitModel
 * @param unitGroupModels 保存DUnitGroupModel
 * @param type            TypeElement
 */
private void processType(ArrayList<DUnitModel> unitModels, ArrayList<DUnitGroupModel> unitGroupModels, TypeElement type) {
	if (type.getKind() != ElementKind.CLASS) {
		mErrorReporter.abortWithError("@" + DUnit.class.getName() + " only applies to classes", type);
	}

	DUnit dUnit = type.getAnnotation(DUnit.class);
	DUnitGroup dUnitGroup = type.getAnnotation(DUnitGroup.class);

	if (dUnit != null) {
		DUnitModel unitModel = mUnitModelUtil.createUnitModel(type, dUnit);
		unitModels.add(unitModel);
	}

	if (dUnitGroup != null) {
		DUnitGroupModel unitGroupModel = mUnitModelUtil.createUnitGroupModel(type, dUnitGroup);
		unitGroupModels.add(unitGroupModel);
	}


}
 

@Override
public WhiteListQuery.Result check(ElementHandle<?> element, WhiteListQuery.Operation operation) {
    if (!operation.equals(WhiteListQuery.Operation.USAGE)) {
        return OK;
    }
    List<WhiteListQuery.RuleDescription> rds = new ArrayList<WhiteListQuery.RuleDescription>();
    if (element.getKind() == ElementKind.CLASS || element.getKind() == ElementKind.INTERFACE) {
        String qn = element.getQualifiedName();
        if (qn.lastIndexOf('.') > 0) {
            String pack = qn.substring(0, qn.lastIndexOf("."));
            synchronized (IMPL_LOCK) {
                if (privatePackages.contains(pack)) {
                    rds.add(PRIVATE_RD);
                }
                if (transitivePackages.contains(pack)) {
                    rds.add(TRANSITIVE_RD);
                }
            }
            if (!rds.isEmpty()) {
                return new WhiteListQuery.Result(rds);
            }
        }
    }
    return OK;
}
 

private static String getParentChain(final TypeElement targetClass) {
	// if input is top level class return it
	// otherwise return the parent chain plus it

	if (targetClass.getNestingKind() == NestingKind.TOP_LEVEL) {
		return targetClass.getSimpleName().toString();
	} else {
		final Element parent = targetClass.getEnclosingElement();

		if (parent.getKind() != ElementKind.CLASS) {
			throw new RuntimeException("Cannot create parent chain. Non-class parent found.");
		}

		return (getParentChain((TypeElement) parent)) + "_" + targetClass.getSimpleName().toString();
	}
}
 

private void collectConstructors(Collection<IConstructor> constructors, Element element){
    if(element == null || element.getKind()!=ElementKind.CLASS) {
        return;
    }
    TypeElement el = (TypeElement) element;
    for(Element sub: el.getEnclosedElements()){
        if(sub.getKind() == ElementKind.CONSTRUCTOR){
            constructors.add(new Constructor(this, (ExecutableElement)sub));
        } else if ((sub.getKind() == ElementKind.CLASS) && (((TypeElement) sub).getSuperclass() != null)){
            TypeMirror supMirror = ((TypeElement) sub).getSuperclass();
            if (supMirror.getKind() == TypeKind.DECLARED) {
                DeclaredType superclassDeclaredType = (DeclaredType)supMirror;
                Element superclassElement = superclassDeclaredType.asElement();  
                collectConstructors(constructors, superclassElement);
            }
        }
    }
}
 

@NonNull
static ElementKind decodeKind (char kind) {
    switch (kind) {
        case EK_CLASS:
        case EK_LOCAL_CLASS:
            return ElementKind.CLASS;
        case EK_INTERFACE:
        case EK_LOCAL_INTERFACE:
            return ElementKind.INTERFACE;
        case EK_ENUM:
        case EK_LOCAL_ENUM:
            return ElementKind.ENUM;
        case EK_ANNOTATION:
        case EK_LOCAL_ANNOTATION:
            return ElementKind.ANNOTATION_TYPE;
        case EK_MODULE:
            return ElementKind.MODULE;
        default:
            throw new IllegalArgumentException ();
    }
}
 

@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    TypeElement annotationElement = processingEnvironment.getElementUtils()
            .getTypeElement(ANNOTATION_CLASS);

    for (Element e : roundEnvironment.getElementsAnnotatedWith(annotationElement)) {
        if (e.getKind() == ElementKind.CLASS) {
            TypeElement te = (TypeElement) e;
            processClass(te);
        }
    }

    return true;
}
 

static boolean checkAbstractValueType(Element element, Collection<String> violations) {
  boolean ofSupportedKind = false
      || element.getKind() == ElementKind.INTERFACE
      || element.getKind() == ElementKind.ANNOTATION_TYPE
      || element.getKind() == ElementKind.CLASS;

  boolean staticOrTopLevel = false
      || element.getEnclosingElement().getKind() == ElementKind.PACKAGE
      || element.getModifiers().contains(Modifier.STATIC);

  boolean nonFinal = !element.getModifiers().contains(Modifier.FINAL);

  boolean publicOrPackageVisible =
      !element.getModifiers().contains(Modifier.PRIVATE)
          && !element.getModifiers().contains(Modifier.PROTECTED);

  if (!ofSupportedKind) {
    violations.add("must be class or interface or annotation type");
  }

  if (!nonFinal) {
    violations.add("must be non-final");
  }

  if (!publicOrPackageVisible) {
    violations.add("should be public or package-visible");
  }

  if (!staticOrTopLevel) {
    violations.add("should be top-level or static inner class");
  }

  return violations.isEmpty();
}
 

/**
 * Return true if the possibleBuilderMethod matches the
 * Style#attributeBuilder() and returns a class.
 *
 * TODO: may need to make this return true if the return type is an interface too...
 *
 * @param possibleBuilderMethod executableElement
 */
private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) {
  if (possibleBuilderMethod.getKind() == ElementKind.METHOD) {
    String detectedAttributeBuilder = valueAttribute.containingType.names()
        .rawFromAttributeBuilder(possibleBuilderMethod.getSimpleName().toString());

    if (detectedAttributeBuilder.isEmpty()) {
      return false;
    }
    ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod;

    return possibleBuilderMethod.getModifiers().containsAll(
        Arrays.asList(Modifier.STATIC, Modifier.PUBLIC))
        && candidateMethod.getParameters().isEmpty()
        && candidateMethod
        .getReturnType().getKind()
        == TypeKind.DECLARED
        && ((DeclaredType) candidateMethod.getReturnType())
        .asElement().getKind() == ElementKind.CLASS;

  } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) {
    if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) {
      return false;
    }

    ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod;

    return candidateConstructor.getModifiers().contains(Modifier.PUBLIC)
        && candidateConstructor.getTypeParameters().isEmpty();
  }
  return false;
}
 

/**
 * Determine if inner class could be a builder.
 *
 * @param possibleBuilderClass nested value element that could be builder class.
 * @return true if it's a static inner class.
 */
private static boolean isPossibleBuilderClass(Element possibleBuilderClass, ValueAttribute valueAttribute) {
  if (possibleBuilderClass.getKind() == ElementKind.CLASS) {

    if (valueAttribute.containingType.names().newTokenInAttributeBuilder()) {
      return possibleBuilderClass.getModifiers().contains(Modifier.STATIC)
          && possibleBuilderClass.getKind() == ElementKind.CLASS;
    }
  }

  return false;
}
 

/**
 * Determines if the Element should be processed as an undefined variable. Currently the implementation
 * only returns true if an undefinedSymbolScope is set, AND the undefined symbol might belong to that scope.
 * If the undefined symbol is qualified (by this. or class.this. or whatever else manner), the method will
 * only return true if the qualifier corresponds to the undefinedSymbolScope.
 * 
 */
private boolean shouldProcessUndefined(Element e) {
    if (e == null || undefinedSymbolScope == null ||
        e.asType().getKind() != TypeKind.ERROR) {
        return false;
    }
    if (e.getKind() == ElementKind.CLASS) {
        return referenceTarget == null || 
            referenceTarget == undefinedSymbolScope;
    }
    return false;
}
 

/** Creates a new instance of InnerToOuterRefactoringUI
 * @param selectedElements Elements the refactoring action was invoked on.
 */
private InnerToOuterRefactoringUI(TreePathHandle sourceType, CompilationInfo info) {
    refactoring = new InnerToOuterRefactoring(sourceType);
    refactoring.setReferenceName("outer"); //NOI18N
    Element temp = sourceType.resolveElement(info);
    className = temp.getSimpleName().toString();
    disableDeclareFields = temp.getModifiers().contains(Modifier.STATIC) || temp.getKind() !=ElementKind.CLASS;
}
 

/**
 * 校验{@code moduleElement}的合法性
 *
 * @param moduleElement 携带@XModule的Element
 * @throws ProcessException
 */
private void verify(Element moduleElement) throws ProcessException {
    XModule XModule = moduleElement.getAnnotation(XModule.class);
    // 检验XModule注解
    if (XModule == null) {
        throw new ProcessException(
                String.format("当前的element（%s）未携带%s注解",
                        moduleElement.toString(),
                        XModule.class.getSimpleName()));
    } else if (XModule.name() == null || XModule.name().isEmpty()) {
        throw new ProcessException(String.format("%s的组件名不能为空", moduleElement.toString()));
    }

    // 检验被XModule注解的是否为class
    if (moduleElement.getKind() != ElementKind.CLASS) {
        throw new ProcessException(
                String.format("%s不是类，只有类才能使用%s",
                        moduleElement.toString(),
                        XModule.class.getSimpleName()));
    }

    TypeElement classElement = (TypeElement) moduleElement;

    // 检验类修饰符
    Set<Modifier> modifiers = classElement.getModifiers();
    if (!modifiers.contains(Modifier.PUBLIC)) {
        throw new ProcessException(
                String.format("被%s注解的%s的权限修饰符必须为public",
                        XModule.class.getSimpleName(),
                        classElement.getQualifiedName().toString()));
    }
    if (modifiers.contains(Modifier.ABSTRACT)) {
        throw new ProcessException(
                String.format("%s是抽象类，不能被%s注解",
                        classElement.getQualifiedName().toString(),
                        XModule.class.getSimpleName()));
    }
}
 

public static boolean isPrimitiveWrapperType(TypeMirror tm) {
    if (tm == null || tm.getKind() != TypeKind.DECLARED) { 
        return false;
    }
    Element el = ((DeclaredType)tm).asElement();
    if (el == null || el.getKind() != ElementKind.CLASS) {
        return false;
    }
    String s = ((TypeElement)el).getQualifiedName().toString();
    return PRIMITIVE_NAMES.contains(s); // NOI18N
}
 

@Override
public List<T> createObjects(TypeElement type) {
    final List<T> result = new ArrayList<T>();
    if (type.getKind() == ElementKind.CLASS || type.getKind() == ElementKind.INTERFACE) {
        if (helper.hasAnyAnnotation(type.getAnnotationMirrors(), getAnnotationTypeNames())) {
            result.add(createObject(helper, type));
        }
    }
    return result;
}
 

/**
 * Checks whether the given type object represents type
 * {@code java.lang.Object}.
 * 
 * @param  type  type to be checked
 * @return  {@code true} if the passed type object represents type
 *          {@code java.lang.Object}, {@code false} otherwise
 */
private static boolean isRootObjectType(DeclaredType type) {
    if (type.getKind() != TypeKind.DECLARED) {
        return false;
    }

    TypeElement elem = (TypeElement) type.asElement();
    return (elem.getKind() == ElementKind.CLASS)
           && (elem.getSuperclass().getKind() == TypeKind.NONE);
}