下面列出了javax.lang.model.element.VariableElement#getEnclosingElement ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public MixinInfo(VariableElement element, CommandSpec mixin) {
this.element = element;
this.mixin = mixin;
String name = element.getAnnotation(CommandLine.Mixin.class).name();
if (name.length() == 0) {
name = element.getSimpleName().toString();
}
this.mixinName = name;
Element targetType = element.getEnclosingElement();
int position = -1;
if (EnumSet.of(ElementKind.METHOD, ElementKind.CONSTRUCTOR).contains(targetType.getKind())) {
List<? extends VariableElement> parameters = ((ExecutableElement) targetType).getParameters();
for (int i = 0; i < parameters.size(); i++) {
if (parameters.get(i).getSimpleName().contentEquals(element.getSimpleName())) {
position = i;
break;
}
}
}
annotatedElement = new TypedMember(element, position);
}
private boolean isValidUsageOfNavigationModelField(VariableElement element) {
final TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
boolean valid = true;
// Verify modifiers.
Set<Modifier> modifiers = element.getModifiers();
if (modifiers.contains(PRIVATE) || modifiers.contains(STATIC)) {
loggingUtil.error(
element,
"@DartModel field must not be private or static. (%s.%s)",
enclosingElement.getQualifiedName(),
element.getSimpleName());
valid = false;
}
return valid;
}
@Override
public boolean isInjectionPoint( VariableElement element )
throws org.netbeans.modules.web.beans.api.model.InjectionPointDefinitionError
{
Element parent = element.getEnclosingElement();
if ( parent instanceof TypeElement){
List<? extends AnnotationMirror> annotations =
getModel().getHelper().getCompilationController().getElements().
getAllAnnotationMirrors(element);
return getModel().getHelper().hasAnnotation(annotations, INJECT_ANNOTATION);
}
else if ( parent instanceof ExecutableElement ){
return isMethodParameterInjection(element,(ExecutableElement)parent);
}
return false;
}
@Override
public TargetClassInfo process(VariableElement variableElement) {
final Element enclosingElement = variableElement.getEnclosingElement();
if (!(enclosingElement instanceof TypeElement)) {
throw new RuntimeException("Only class fields could be annotated as @InjectPresenter: " +
variableElement + " at " + enclosingElement);
}
if (presentersContainers.contains(enclosingElement)) {
return null;
}
final TypeElement presentersContainer = (TypeElement) enclosingElement;
presentersContainers.add(presentersContainer);
// gather presenter fields info
List<TargetPresenterField> fields = collectFields(presentersContainer);
bindProvidersToFields(fields, collectPresenterProviders(presentersContainer));
bindTagProvidersToFields(fields, collectTagProviders(presentersContainer));
return new TargetClassInfo(presentersContainer, fields);
}
@Override
protected void processView(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
Set<? extends Element> elementsWithBind = roundEnv.getElementsAnnotatedWith(BindView.class);
for (Element element : elementsWithBind) {
if (!checkAnnotationValid(element, BindView.class)) continue;
VariableElement variableElement = (VariableElement) element;
TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
String fullClassName = classElement.getQualifiedName().toString();
Briefnessor briefnessor = mProxyMap.get(fullClassName);
if (briefnessor == null) {
briefnessor = new Briefnessor(elementUtils, classElement);
mProxyMap.put(fullClassName, briefnessor);
}
}
}
private void processInjectAnnotatedField(
VariableElement fieldElement,
Map<TypeElement, List<FieldInjectionTarget>> mapTypeElementToMemberInjectorTargetList) {
TypeElement enclosingElement = (TypeElement) fieldElement.getEnclosingElement();
// Verify common generated code restrictions.
if (!isValidInjectAnnotatedFieldOrParameter(fieldElement)) {
return;
}
List<FieldInjectionTarget> fieldInjectionTargetList =
mapTypeElementToMemberInjectorTargetList.get(enclosingElement);
if (fieldInjectionTargetList == null) {
fieldInjectionTargetList = new ArrayList<>();
mapTypeElementToMemberInjectorTargetList.put(enclosingElement, fieldInjectionTargetList);
}
mapTypeToMostDirectSuperTypeThatNeedsInjection(enclosingElement);
fieldInjectionTargetList.add(createFieldOrParamInjectionTarget(fieldElement));
}
public MethodParameterElement(ProbingEnvironment env, Archive archive, VariableElement element, TypeMirror type) {
super(env, archive, element, type);
if (element.getEnclosingElement() instanceof ExecutableElement) {
index = ((ExecutableElement) element.getEnclosingElement()).getParameters().indexOf(element);
} else {
throw new IllegalArgumentException(
"MethodParameterElement cannot be constructed using a VariableElement not representing a method parameter.");
}
}
@Override
public Void visitVariable(VariableElement e, Boolean highlightName) {
modifier(e.getModifiers());
result.append(getTypeName(info, e.asType(), true));
result.append(' ');
boldStartCheck(highlightName);
result.append(e.getSimpleName());
boldStopCheck(highlightName);
if (highlightName) {
if (e.getConstantValue() != null) {
result.append(" = ");
result.append(StringEscapeUtils.escapeHtml(e.getConstantValue().toString()));
}
Element enclosing = e.getEnclosingElement();
if (e.getKind() != ElementKind.PARAMETER && e.getKind() != ElementKind.LOCAL_VARIABLE
&& e.getKind() != ElementKind.RESOURCE_VARIABLE && e.getKind() != ElementKind.EXCEPTION_PARAMETER
&& !TreeShims.BINDING_VARIABLE.equals(e.getKind().name())) {
result.append(" in ");
//short typename:
result.append(getTypeName(info, enclosing.asType(), true));
}
}
return null;
}
/**
* guess getter from var
*
* @param variableElement
* @return
*/
public static ExecutableElement guessGetter(VariableElement variableElement) {
String name = variableElement.getSimpleName().toString();
String guessGetterName = StringHelper.firstUpper(name);
TypeElement typeElement = (TypeElement) variableElement.getEnclosingElement();
for (ExecutableElement executableElement : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
if (executableElement.getSimpleName().contentEquals("get" + guessGetterName) || executableElement.getSimpleName().contentEquals("is" + guessGetterName)) {
return executableElement;
}
}
Logger.getLogger(JavaSourceParserUtil.class.getName()).log(Level.INFO, "Cannot detect getter associated with var: {0}", guessGetterName);
return null;
}
@Override
public void analyze( VariableElement element, TypeMirror elementType,
TypeElement parent, AtomicBoolean cancel,
CdiAnalysisResult result )
{
CompilationInfo compInfo = result.getInfo();
if (!AnnotationUtil.hasAnnotation(element, AnnotationUtil.DELEGATE_FQN,
compInfo))
{
return;
}
result.requireCdiEnabled(element);
if (!AnnotationUtil.hasAnnotation(element, AnnotationUtil.INJECT_FQN,
compInfo))
{
result.addError(element, NbBundle.getMessage(
DelegateFieldAnalizer.class,
"ERR_DelegateHasNoInject")); // NOI18N
}
Element clazz = element.getEnclosingElement();
if (!AnnotationUtil.hasAnnotation(clazz, AnnotationUtil.DECORATOR,
compInfo))
{
result.addError(element, NbBundle.getMessage(
DelegateFieldAnalizer.class,
"ERR_DelegateIsNotInDecorator")); // NOI18N
}
EditorAnnotationsHelper helper = EditorAnnotationsHelper.getInstance(
result);
if ( helper != null ){
helper.addDelegate(result, element );
}
if ( cancel.get()){
return;
}
checkDelegateType(element, elementType, parent, result );
}
protected DependencyInjectionResult lookupInjectables( VariableElement element,
DeclaredType parentType , ResultLookupStrategy strategy, AtomicBoolean cancel)
{
/*
* Element could be injection point. One need first if all to check this.
*/
Element parent = element.getEnclosingElement();
if(cancel.get()) {
return null;
}
if ( parent instanceof TypeElement){
return findVariableInjectable(element, parentType , strategy, cancel);
}
else if ( parent instanceof ExecutableElement ){
// Probably injected field in method. One need to check method.
/*
* There are two cases where parameter is injected :
* 1) Method has some annotation which require from
* parameters to be injection points.
* 2) Method is disposer method. In this case injectable
* is producer corresponding method.
*/
return findParameterInjectable(element, parentType, strategy, cancel);
}
return null;
}
protected boolean isValidInjectAnnotatedFieldOrParameter(VariableElement variableElement) {
TypeElement enclosingElement = (TypeElement) variableElement.getEnclosingElement();
// Verify modifiers.
Set<Modifier> modifiers = variableElement.getModifiers();
if (modifiers.contains(PRIVATE)) {
error(
variableElement,
"@Inject annotated fields must be non private : %s#%s",
enclosingElement.getQualifiedName(),
variableElement.getSimpleName());
return false;
}
// Verify parentScope modifiers.
Set<Modifier> parentModifiers = enclosingElement.getModifiers();
if (parentModifiers.contains(PRIVATE)) {
error(
variableElement,
"@Injected fields in class %s. The class must be non private.",
enclosingElement.getSimpleName());
return false;
}
if (!isValidInjectedType(variableElement)) {
return false;
}
return true;
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}
@Override
public void initialize() {
if (initialized) {
return;
}
if (handle!=null && handle.getKind() != Tree.Kind.LABELED_STATEMENT &&
handle.getElementHandle() != null
&& (handle.getElementHandle().getKind() == ElementKind.FIELD
|| handle.getElementHandle().getKind() == ElementKind.CLASS
|| handle.getElementHandle().getKind() == ElementKind.METHOD)) {
JavaSource source = JavaSource.forFileObject(handle.getFileObject());
CancellableTask<CompilationController> task = new CancellableTask<CompilationController>() {
@Override
public void cancel() {
throw new UnsupportedOperationException("Not supported yet."); // NOI18N
}
@Override
public void run(CompilationController info) throws Exception {
info.toPhase(Phase.RESOLVED);
if(handle.getElementHandle().getKind() == ElementKind.FIELD) {
VariableElement element = (VariableElement) handle.resolveElement(info);
if(element == null) {
LOG.log(Level.WARNING, "Cannot resolve ElementHandle {0} {1}", new Object[] {handle, info.getClasspathInfo()});
return;
}
TypeElement parent = (TypeElement) element.getEnclosingElement();
boolean hasGetters = false;
for (ExecutableElement method : ElementFilter.methodsIn(parent.getEnclosedElements())) {
if (RefactoringUtils.isGetter(info, method, element) || RefactoringUtils.isSetter(info, method, element)) {
hasGetters = true;
break;
}
}
if (hasGetters) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
renameGettersAndCheckersCheckBox.setVisible(true);
}
});
}
}
if(handle.getElementHandle().getKind() == ElementKind.CLASS || handle.getElementHandle().getKind() == ElementKind.METHOD) {
final Element methodElement = handle.resolveElement(info);
if(methodElement == null) {
LOG.log(Level.WARNING, "Cannot resolve ElementHandle {0} {1}", new Object[] {handle, info.getClasspathInfo()});
return;
}
final FileObject fileObject = handle.getFileObject();
Collection<? extends TestLocator> testLocators = Lookup.getDefault().lookupAll(TestLocator.class);
for (final TestLocator testLocator : testLocators) {
if(testLocator.appliesTo(fileObject)) {
if(testLocator.asynchronous()) {
testLocator.findOpposite(fileObject, -1, new TestLocator.LocationListener() {
@Override
public void foundLocation(FileObject fo, LocationResult location) {
if(handle.getElementHandle().getKind() == ElementKind.CLASS) {
addTestFile(location, testLocator);
} else if(handle.getElementHandle().getKind() == ElementKind.METHOD) {
addTestMethod(location, testLocator, methodElement);
}
}
});
} else {
if(handle.getElementHandle().getKind() == ElementKind.CLASS) {
addTestFile(testLocator.findOpposite(fileObject, -1), testLocator);
} else if (handle.getElementHandle().getKind() == ElementKind.METHOD) {
addTestMethod(testLocator.findOpposite(fileObject, -1), testLocator, methodElement);
}
}
}
}
}
}
};
try {
source.runUserActionTask(task, true);
} catch (IOException ioe) {
throw new RuntimeException(ioe);
}
}
initialized = true;
}
public ExtraAnnotatedClass(VariableElement annotatedVariableElement, Elements elements, Types types) {
this.annotatedVariableElement = annotatedVariableElement;
key = annotatedVariableElement.getSimpleName().toString();
// Get the full QualifiedTypeName
final TypeElement parent = (TypeElement) annotatedVariableElement.getEnclosingElement();
if (types.isSubtype(parent.asType(), elements.getTypeElement("android.app.Activity").asType())) {
supportedType = SupportedType.ACTIVITY;
} else if (types.isSubtype(parent.asType(), elements.getTypeElement("android.app.Service").asType())) {
supportedType = SupportedType.SERVICE;
} else if (types.isSubtype(parent.asType(), elements.getTypeElement("android.app.Fragment").asType())
|| types.isSubtype(parent.asType(), elements.getTypeElement("android.support.v4.app.Fragment").asType())) {
supportedType = SupportedType.FRAGMENT;
} else {
supportedType = SupportedType.NOP;
}
qualifiedClassName = parent.getQualifiedName().toString();
// Get the full Qualified of DataType.
dataType = annotatedVariableElement.asType();
dataTypeQualifiedClassName = dataType.toString();
extraBinder = ExtraBinderProvider.get(dataTypeQualifiedClassName);
if (extraBinder != ExtraBinder.NOP) {
return;
}
// Check if data type is kind of Parcelable.
if (types.isSubtype(dataType, elements.getTypeElement("android.os.Parcelable").asType())) {
extraBinder = ExtraBinderProvider.get("android.os.Parcelable");
if (extraBinder != ExtraBinder.NOP) {
return;
}
}
try {
// Check if data type is kind of Array.
dataTypeQualifiedClassName = ((ArrayType) dataType).getComponentType().toString();
final TypeMirror componentTypeMirror = elements.getTypeElement(dataTypeQualifiedClassName).asType();
if (types.isSubtype(componentTypeMirror, elements.getTypeElement("android.os.Parcelable").asType())) {
extraBinder = ExtraBinderProvider.get("android.os.Parcelable[]");
if (extraBinder != ExtraBinder.NOP) {
return;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}
public TypeElement getDeclaringClassForField(VariableElement f) {
return (TypeElement) f.getEnclosingElement();
}