|
1
14
15
16 package org.aspectj.runtime.reflect;
17
18 import java.lang.reflect.Constructor  ;
19 import java.lang.reflect.Member ;
20 import java.lang.reflect.Method ;
21 import java.util.Hashtable ;
22 import java.util.StringTokenizer ;
23
24 import org.aspectj.lang.*;
25 import org.aspectj.lang.reflect.*;
26
27 public final class Factory {
28 Class lexicalClass;
29 ClassLoader lookupClassLoader;
30 String filename;
31
32 static Hashtable prims = new Hashtable ();
33 static {
34 prims.put("void", Void.TYPE);
35 prims.put("boolean", Boolean.TYPE);
36 prims.put("byte", Byte.TYPE);
37 prims.put("char", Character.TYPE);
38 prims.put("short", Short.TYPE);
39 prims.put("int", Integer.TYPE);
40 prims.put("long", Long.TYPE);
41 prims.put("float", Float.TYPE);
42 prims.put("double", Double.TYPE);
43 }
44
45 static Class makeClass(String s, ClassLoader loader) {
46 if (s.equals("*")) return null;
47 Class ret = (Class )prims.get(s);
48 if (ret != null) return ret;
49 try {
50
53 if (loader == null) {
54 return Class.forName(s);
55 } else {
56 return Class.forName(s,false,loader);
59 }
60 } catch (ClassNotFoundException e) {
61 return ClassNotFoundException .class;
64 }
65 }
66
67 public Factory(String filename, Class lexicalClass) {
68 this.filename = filename;
70 this.lexicalClass = lexicalClass;
71 lookupClassLoader = lexicalClass.getClassLoader();
72 }
73
74
75
76 public JoinPoint.StaticPart makeSJP(String kind, Signature sig, SourceLocation loc) {
77 return new JoinPointImpl.StaticPartImpl(kind, sig, loc);
78 }
79
80 public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l, int c) {
81 return new JoinPointImpl.StaticPartImpl(kind, sig, makeSourceLoc(l, c));
82 }
83
84 public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l) {
85 return new JoinPointImpl.StaticPartImpl(kind, sig, makeSourceLoc(l, -1));
86 }
87
88 public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, SourceLocation loc) {
89 return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, loc);
90 }
91
92 public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l, int c) {
93 return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, makeSourceLoc(l, c));
94 }
95
96 public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l) {
97 return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, makeSourceLoc(l, -1));
98 }
99
100 public static JoinPoint.StaticPart makeEncSJP(Member member) {
101 Signature sig = null;
102 String kind = null;
103 if (member instanceof Method ) {
104 Method method = (Method ) member;
105 sig = new MethodSignatureImpl(method.getModifiers(),method.getName(),
106 method.getDeclaringClass(),method.getParameterTypes(),
107 new String [method.getParameterTypes().length],
108 method.getExceptionTypes(),method.getReturnType());
109 kind = JoinPoint.METHOD_EXECUTION;
110 } else if (member instanceof Constructor ) {
111 Constructor cons = (Constructor ) member;
112 sig = new ConstructorSignatureImpl(cons.getModifiers(),cons.getDeclaringClass(),
113 cons.getParameterTypes(),
114 new String [cons.getParameterTypes().length],
115 cons.getExceptionTypes());
116 kind = JoinPoint.CONSTRUCTOR_EXECUTION;
117 } else {
118 throw new IllegalArgumentException ("member must be either a method or constructor");
119 }
120 return new JoinPointImpl.EnclosingStaticPartImpl(kind,sig,null);
121 }
122
123 private static Object [] NO_ARGS = new Object [0];
124 public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
125 Object _this, Object target)
126 {
127 return new JoinPointImpl(staticPart, _this, target, NO_ARGS);
128 }
129
130 public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
131 Object _this, Object target, Object arg0)
132 {
133 return new JoinPointImpl(staticPart, _this, target, new Object [] {arg0});
134 }
135
136 public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
137 Object _this, Object target, Object arg0, Object arg1)
138 {
139 return new JoinPointImpl(staticPart, _this, target, new Object [] {arg0, arg1});
140 }
141
142
143 public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
144 Object _this, Object target, Object [] args)
145 {
146 return new JoinPointImpl(staticPart, _this, target, args);
147 }
148
149 public MethodSignature makeMethodSig(String stringRep) {
150 MethodSignatureImpl ret = new MethodSignatureImpl(stringRep);
151 ret.setLookupClassLoader(lookupClassLoader);
152 return ret;
153 }
154
155
156 public MethodSignature makeMethodSig(String modifiers, String methodName, String declaringType, String paramTypes, String paramNames, String exceptionTypes, String returnType) {
157 int modifiersAsInt = Integer.parseInt(modifiers, 16);
158
159 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
160
161 StringTokenizer st = new StringTokenizer (paramTypes, ":");
162 int numParams = st.countTokens();
163 Class [] paramTypeClasses = new Class [numParams];
164 for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
165
166 st = new StringTokenizer (paramNames, ":");
167 numParams = st.countTokens();
168 String [] paramNamesArray = new String [numParams];
169 for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
170
171 st = new StringTokenizer (exceptionTypes, ":");
172 numParams = st.countTokens();
173 Class [] exceptionTypeClasses = new Class [numParams];
174 for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
175
176 Class returnTypeClass = makeClass(returnType,lookupClassLoader);
177
178 MethodSignatureImpl ret =
179 new MethodSignatureImpl(modifiersAsInt, methodName, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses, returnTypeClass);
180
181 return ret;
182 }
183
184 public MethodSignature makeMethodSig(int modifiers, String name, Class declaringType,
185 Class [] parameterTypes, String [] parameterNames, Class [] exceptionTypes,
186 Class returnType) {
187 MethodSignatureImpl ret = new MethodSignatureImpl(modifiers,name,declaringType,parameterTypes,parameterNames,exceptionTypes,returnType);
188 ret.setLookupClassLoader(lookupClassLoader);
189 return ret;
190 }
191
192 public ConstructorSignature makeConstructorSig(String stringRep) {
193 ConstructorSignatureImpl ret = new ConstructorSignatureImpl(stringRep);
194 ret.setLookupClassLoader(lookupClassLoader);
195 return ret;
196 }
197
198 public ConstructorSignature makeConstructorSig(String modifiers, String declaringType, String paramTypes, String paramNames, String exceptionTypes) {
199 int modifiersAsInt = Integer.parseInt(modifiers, 16);
200
201 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
202
203 StringTokenizer st = new StringTokenizer (paramTypes, ":");
204 int numParams = st.countTokens();
205 Class [] paramTypeClasses = new Class [numParams];
206 for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
207
208 st = new StringTokenizer (paramNames, ":");
209 numParams = st.countTokens();
210 String [] paramNamesArray = new String [numParams];
211 for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
212
213 st = new StringTokenizer (exceptionTypes, ":");
214 numParams = st.countTokens();
215 Class [] exceptionTypeClasses = new Class [numParams];
216 for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
217
218 ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiersAsInt, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses);
219 ret.setLookupClassLoader(lookupClassLoader);
220 return ret;
221 }
222
223
224 public ConstructorSignature makeConstructorSig(int modifiers, Class declaringType,
225 Class [] parameterTypes, String [] parameterNames, Class [] exceptionTypes) {
226 ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiers,declaringType,parameterTypes,parameterNames,exceptionTypes);
227 ret.setLookupClassLoader(lookupClassLoader);
228 return ret;
229 }
230
231 public FieldSignature makeFieldSig(String stringRep) {
232 FieldSignatureImpl ret = new FieldSignatureImpl(stringRep);
233 ret.setLookupClassLoader(lookupClassLoader);
234 return ret;
235 }
236
237
238 public FieldSignature makeFieldSig(String modifiers, String name, String declaringType, String fieldType) {
239 int modifiersAsInt = Integer.parseInt(modifiers, 16);
240 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
241 Class fieldTypeClass = makeClass(fieldType,lookupClassLoader);
242
243 FieldSignatureImpl ret = new FieldSignatureImpl(modifiersAsInt, name, declaringTypeClass, fieldTypeClass);
244 ret.setLookupClassLoader(lookupClassLoader);
245 return ret;
246 }
247
248 public FieldSignature makeFieldSig(int modifiers, String name, Class declaringType,
249 Class fieldType) {
250 FieldSignatureImpl ret = new FieldSignatureImpl(modifiers,name,declaringType,fieldType);
251 ret.setLookupClassLoader(lookupClassLoader);
252 return ret;
253 }
254
255 public AdviceSignature makeAdviceSig(String stringRep) {
256 AdviceSignatureImpl ret = new AdviceSignatureImpl(stringRep);
257 ret.setLookupClassLoader(lookupClassLoader);
258 return ret;
259 }
260
261 public AdviceSignature makeAdviceSig(String modifiers, String name, String declaringType, String paramTypes, String paramNames, String exceptionTypes, String returnType) {
262 int modifiersAsInt = Integer.parseInt(modifiers, 16);
263
264 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
265
266 StringTokenizer st = new StringTokenizer (paramTypes, ":");
267 int numParams = st.countTokens();
268 Class [] paramTypeClasses = new Class [numParams];
269 for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
270
271 st = new StringTokenizer (paramNames, ":");
272 numParams = st.countTokens();
273 String [] paramNamesArray = new String [numParams];
274 for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
275
276 st = new StringTokenizer (exceptionTypes, ":");
277 numParams = st.countTokens();
278 Class [] exceptionTypeClasses = new Class [numParams];
279 for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);;
280
281 Class returnTypeClass = makeClass(returnType,lookupClassLoader);
282
283 AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiersAsInt, name, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses, returnTypeClass);
284 ret.setLookupClassLoader(lookupClassLoader);
285 return ret;
286 }
287
288 public AdviceSignature makeAdviceSig(int modifiers, String name, Class declaringType,
289 Class [] parameterTypes, String [] parameterNames, Class [] exceptionTypes,
290 Class returnType) {
291 AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiers,name,declaringType,parameterTypes,parameterNames,exceptionTypes,returnType);
292 ret.setLookupClassLoader(lookupClassLoader);
293 return ret;
294 }
295
296 public InitializerSignature makeInitializerSig(String stringRep) {
297 InitializerSignatureImpl ret = new InitializerSignatureImpl(stringRep);
298 ret.setLookupClassLoader(lookupClassLoader);
299 return ret;
300 }
301
302 public InitializerSignature makeInitializerSig(String modifiers, String declaringType) {
303 int modifiersAsInt = Integer.parseInt(modifiers, 16);
304 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
305
306 InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiersAsInt, declaringTypeClass);
307 ret.setLookupClassLoader(lookupClassLoader);
308 return ret;
309 }
310
311 public InitializerSignature makeInitializerSig(int modifiers, Class declaringType) {
312 InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiers,declaringType);
313 ret.setLookupClassLoader(lookupClassLoader);
314 return ret;
315 }
316
317 public CatchClauseSignature makeCatchClauseSig(String stringRep) {
318 CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(stringRep);
319 ret.setLookupClassLoader(lookupClassLoader);
320 return ret;
321 }
322
323 public CatchClauseSignature makeCatchClauseSig(String declaringType, String parameterType, String parameterName) {
324 Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
325
326 StringTokenizer st = new StringTokenizer (parameterType, ":");
327 Class parameterTypeClass = makeClass(st.nextToken(),lookupClassLoader);
328
329 st = new StringTokenizer (parameterName, ":");
330 String parameterNameForReturn = st.nextToken();
331
332 CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringTypeClass, parameterTypeClass, parameterNameForReturn);
333 ret.setLookupClassLoader(lookupClassLoader);
334 return ret;
335 }
336
337 public CatchClauseSignature makeCatchClauseSig(Class declaringType,
338 Class parameterType, String parameterName) {
339 CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringType,parameterType,parameterName);
340 ret.setLookupClassLoader(lookupClassLoader);
341 return ret;
342 }
343
344 public LockSignature makeLockSig(String stringRep) {
345 LockSignatureImpl ret = new LockSignatureImpl(stringRep);
346 ret.setLookupClassLoader(lookupClassLoader);
347 return ret;
348 }
349 public LockSignature makeLockSig() {
350 Class declaringTypeClass = makeClass("Ljava/lang/Object;",lookupClassLoader);
351 LockSignatureImpl ret = new LockSignatureImpl(declaringTypeClass);
352 ret.setLookupClassLoader(lookupClassLoader);
353 return ret;
354 }
355 public LockSignature makeLockSig(Class declaringType) {
356 LockSignatureImpl ret = new LockSignatureImpl(declaringType);
357 ret.setLookupClassLoader(lookupClassLoader);
358 return ret;
359 }
360
361 public UnlockSignature makeUnlockSig(String stringRep) {
362 UnlockSignatureImpl ret = new UnlockSignatureImpl(stringRep);
363 ret.setLookupClassLoader(lookupClassLoader);
364 return ret;
365 }
366 public UnlockSignature makeUnlockSig() {
367 Class declaringTypeClass = makeClass("Ljava/lang/Object;",lookupClassLoader);
368 UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringTypeClass);
369 ret.setLookupClassLoader(lookupClassLoader);
370 return ret;
371 }
372 public UnlockSignature makeUnlockSig(Class declaringType) {
373 UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringType);
374 ret.setLookupClassLoader(lookupClassLoader);
375 return ret;
376 }
377
378
379 public SourceLocation makeSourceLoc(int line, int col)
380 {
381 return new SourceLocationImpl(lexicalClass, this.filename, line);
382 }
383 }
384 |
Popular Tags |
Java API By Example, From Geeks To Geeks.