|
1
11 package org.eclipse.jdt.internal.compiler.apt.model;
12
13 import java.util.ArrayList  ;
14 import java.util.Collections ;
15 import java.util.List ;
16 import java.util.Set ;
17
18 import javax.lang.model.element.Element;
19 import javax.lang.model.element.ElementKind;
20 import javax.lang.model.element.ElementVisitor;
21 import javax.lang.model.element.ExecutableElement;
22 import javax.lang.model.element.Modifier;
23 import javax.lang.model.element.Name;
24 import javax.lang.model.element.NestingKind;
25 import javax.lang.model.element.PackageElement;
26 import javax.lang.model.element.TypeElement;
27 import javax.lang.model.element.TypeParameterElement;
28 import javax.lang.model.element.VariableElement;
29 import javax.lang.model.type.TypeKind;
30 import javax.lang.model.type.TypeMirror;
31
32 import org.eclipse.jdt.core.compiler.CharOperation;
33 import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl;
34 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
35 import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
36 import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
37 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
38 import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
39 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
40 import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
41
42 public class TypeElementImpl extends ElementImpl implements TypeElement {
43
44
49 TypeElementImpl(BaseProcessingEnvImpl env, ReferenceBinding binding) {
50 super(env, binding);
51 }
52
53 @Override
54 public <R, P> R accept(ElementVisitor<R, P> v, P p)
55 {
56 return v.visitType(this, p);
57 }
58
59 @Override
60 protected AnnotationBinding[] getAnnotationBindings()
61 {
62 return ((ReferenceBinding)_binding).getAnnotations();
63 }
64
65 @Override
66 public List <? extends Element> getEnclosedElements() {
67 ReferenceBinding binding = (ReferenceBinding)_binding;
68 List <Element> enclosed = new ArrayList <Element>(binding.fieldCount() + binding.methods().length);
69 for (MethodBinding method : binding.methods()) {
70 ExecutableElement executable = new ExecutableElementImpl(_env, method);
71 enclosed.add(executable);
72 }
73 for (FieldBinding field : binding.fields()) {
74 if (!field.isSynthetic()) {
76 VariableElement variable = new VariableElementImpl(_env, field);
77 enclosed.add(variable);
78 }
79 }
80 for (ReferenceBinding memberType : binding.memberTypes()) {
81 TypeElement type = new TypeElementImpl(_env, memberType);
82 enclosed.add(type);
83 }
84 return Collections.unmodifiableList(enclosed);
85 }
86
87 @Override
88 public Element getEnclosingElement() {
89 ReferenceBinding binding = (ReferenceBinding)_binding;
90 ReferenceBinding enclosingType = binding.enclosingType();
91 if (null == enclosingType) {
92 return _env.getFactory().newPackageElement(binding.fPackage);
94 }
95 else {
96 return _env.getFactory().newElement(binding.enclosingType());
97 }
98 }
99
100 @Override
101 public String getFileName() {
102 char[] name = ((ReferenceBinding)_binding).getFileName();
103 if (name == null)
104 return null;
105 return new String (name);
106 }
107
108 @Override
109 public List <? extends TypeMirror> getInterfaces() {
110 ReferenceBinding binding = (ReferenceBinding)_binding;
111 if (null == binding.superInterfaces() || binding.superInterfaces().length == 0) {
112 return Collections.emptyList();
113 }
114 List <TypeMirror> interfaces = new ArrayList <TypeMirror>(binding.superInterfaces().length);
115 for (ReferenceBinding interfaceBinding : binding.superInterfaces()) {
116 TypeMirror interfaceType = _env.getFactory().newTypeMirror(interfaceBinding);
117 interfaces.add(interfaceType);
118 }
119 return Collections.unmodifiableList(interfaces);
120 }
121
122 @Override
123 public ElementKind getKind() {
124 ReferenceBinding refBinding = (ReferenceBinding)_binding;
125 if (refBinding.isEnum()) {
127 return ElementKind.ENUM;
128 }
129 else if (refBinding.isAnnotationType()) {
130 return ElementKind.ANNOTATION_TYPE;
131 }
132 else if (refBinding.isInterface()) {
133 return ElementKind.INTERFACE;
134 }
135 else if (refBinding.isClass()) {
136 return ElementKind.CLASS;
137 }
138 else {
139 throw new IllegalArgumentException ("TypeElement " + new String (refBinding.shortReadableName()) + " has unexpected attributes " + refBinding.modifiers); }
142 }
143
144 @Override
145 public Set <Modifier> getModifiers()
146 {
147 ReferenceBinding refBinding = (ReferenceBinding)_binding;
148 int modifiers = refBinding.modifiers;
149 if (refBinding.isInterface() && refBinding.isNestedType()) {
150 modifiers |= ClassFileConstants.AccStatic;
151 }
152 return Factory.getModifiers(modifiers, getKind(), refBinding.isBinaryBinding());
153 }
154
155 @Override
156 public NestingKind getNestingKind() {
157 ReferenceBinding refBinding = (ReferenceBinding)_binding;
158 if (refBinding.isAnonymousType()) {
159 return NestingKind.ANONYMOUS;
160 } else if (refBinding.isLocalType()) {
161 return NestingKind.LOCAL;
162 } else if (refBinding.isMemberType()) {
163 return NestingKind.MEMBER;
164 }
165 return NestingKind.TOP_LEVEL;
166 }
167
168 @Override
169 PackageElement getPackage()
170 {
171 ReferenceBinding binding = (ReferenceBinding)_binding;
172 return _env.getFactory().newPackageElement((PackageBinding)binding.fPackage);
173 }
174
175 @Override
176 public Name getQualifiedName() {
177 ReferenceBinding binding = (ReferenceBinding)_binding;
178 char[] qName;
179 if (binding.isMemberType()) {
180 qName = CharOperation.concatWith(binding.enclosingType().compoundName, binding.sourceName, '.');
181 CharOperation.replace(qName, '$', '.');
182 } else {
183 qName = CharOperation.concatWith(binding.compoundName, '.');
184 }
185 return new NameImpl(qName);
186 }
187
188
193 @Override
194 public Name getSimpleName()
195 {
196 ReferenceBinding binding = (ReferenceBinding)_binding;
197 return new NameImpl(binding.sourceName());
198 }
199
200 @Override
201 public TypeMirror getSuperclass() {
202 ReferenceBinding binding = (ReferenceBinding)_binding;
203 ReferenceBinding superBinding = binding.superclass();
204 if (null == superBinding || binding.isInterface()) {
205 return _env.getFactory().getNoType(TypeKind.NONE);
206 }
207 return _env.getFactory().newDeclaredType(superBinding);
209 }
210
211 @Override
212 public List <? extends TypeParameterElement> getTypeParameters() {
213 ReferenceBinding binding = (ReferenceBinding)_binding;
214 TypeVariableBinding[] variables = binding.typeVariables();
215 if (variables.length == 0) {
216 return Collections.emptyList();
217 }
218 List <TypeParameterElement> params = new ArrayList <TypeParameterElement>(variables.length);
219 for (TypeVariableBinding variable : variables) {
220 params.add(_env.getFactory().newTypeParameterElement(variable, this));
221 }
222 return Collections.unmodifiableList(params);
223 }
224
225 @Override
226 public boolean hides(Element hidden)
227 {
228 if (!(hidden instanceof TypeElementImpl)) {
229 return false;
230 }
231 ReferenceBinding hiddenBinding = (ReferenceBinding)((TypeElementImpl)hidden)._binding;
232 if (hiddenBinding.isPrivate()) {
233 return false;
234 }
235 ReferenceBinding hiderBinding = (ReferenceBinding)_binding;
236 if (hiddenBinding == hiderBinding) {
237 return false;
238 }
239 if (!hiddenBinding.isMemberType() || !hiderBinding.isMemberType()) {
240 return false;
241 }
242 if (!CharOperation.equals(hiddenBinding.sourceName, hiderBinding.sourceName)) {
243 return false;
244 }
245 return null != hiderBinding.enclosingType().findSuperTypeWithSameErasure(hiddenBinding.enclosingType());
246 }
247
248 @Override
249 public String toString() {
250 ReferenceBinding binding = (ReferenceBinding) this._binding;
251 char[] concatWith = CharOperation.concatWith(binding.compoundName, '.');
252 if (binding.isNestedType()) {
253 CharOperation.replace(concatWith, '$', '.');
254 return new String (concatWith);
255 }
256 return new String (concatWith);
257
258 }
259
260 }
261 |
Popular Tags |
Java API By Example, From Geeks To Geeks.