1 /***************************************************************************************
2 * Copyright (c) Jonas Bon?r, Alexandre Vasseur. All rights reserved. *
3 * http://aspectwerkz.codehaus.org *
4 * ---------------------------------------------------------------------------------- *
5 * The software in this package is published under the terms of the LGPL license *
6 * a copy of which has been included with this distribution in the license.txt file. *
7 **************************************************************************************/
8 package test.args;
9
10 import org.codehaus.aspectwerkz.definition.Pointcut;
11 import org.codehaus.aspectwerkz.joinpoint.JoinPoint;
12 import test.Loggable;
13
14 /***
15 * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur</a>
16 */
17 public class ArgsAspect {
18
19
20
21 /***
22 * @Expression within(test.args.ArgsAdviceTest)
23 */
24 Pointcut in_scope;
25
26 /***
27 * @Expression in_scope && execution(* matchAll(..)) && args(String, String, long)
28 */
29 Pointcut pc_matchAll;
30
31 /***
32 * @Expression in_scope && execution(* matchAllWithWildcard(..)) && args(..)
33 */
34 Pointcut pc_matchAllWithWildcard;
35
36 /***
37 * @Expression in_scope && execution(* getFirst(..)) && args(s, ..)
38 */
39 void pc_getFirst(String s) {
40 ;
41 }
42
43 /***
44 * @Expression in_scope && execution(* changeArg(..)) && args(String, s, long)
45 */
46 Pointcut pc_changeArg(StringBuffer s) {
47 return null;
48 }
49
50 /***
51 * @Expression in_scope && execution(* orderChangedInPointcutSignature(..)) && args(s0, s1, long)
52 */
53 Pointcut pc_orderChangedInPointcutSignature(String s1, String s0) {
54 return null;
55 }
56
57 /***
58 * @Expression in_scope && execution(* orderChangedInAdviceSignature(..)) && args(s0, s1, long)
59 */
60 Pointcut pc_orderChangedInAdviceSignature(String s0, String s1) {
61 return null;
62 }
63
64 /***
65 * @Expression in_scope && execution(* orderChangedInPointcutAndAdviceSignature(..)) && args(s0, s1, long)
66 */
67 Pointcut pc_orderChangedInPointcutAndAdviceSignature(String s1, String s0) {
68 return null;
69 }
70
71 /***
72 * @Before in_scope && execution(* singleAndDotDot(..)) && args(i)
73 */
74 public void singleAndDotDot(JoinPoint joinPoint, int i) {
75 ((Loggable) joinPoint.getTarget()).log("before " + i + " ");
76 }
77
78 /***
79 * @Before in_scope && execution(* withArray(..)) && args(l, s, matrix)
80 */
81 public void withArray(JoinPoint joinPoint, long l, String s, int[][] matrix) {
82 String iis = "";
83 for (int i = 0; i < matrix.length; i++) {
84 for (int j = 0; j < matrix[i].length; j++) {
85 iis += ""+matrix[i][j]+"-";
86 }
87 }
88 ((Loggable) joinPoint.getTarget()).log("before " + l + " " + s + " " + iis + " ");
89 }
90
91 /***
92 * @Before pc_matchAll || pc_matchAllWithWildcard
93 */
94 public void matchAllBefore(JoinPoint joinPoint) {
95 ((Loggable) joinPoint.getTarget()).log("before ");
96 }
97
98 /***
99 * @After pc_matchAll || pc_matchAllWithWildcard
100 */
101 public void matchAllAfter(JoinPoint joinPoint) {
102 ((Loggable) joinPoint.getTarget()).log("after ");
103 }
104
105 /***
106 * @Around pc_matchAll || pc_matchAllWithWildcard
107 */
108 public Object matchAllAround(JoinPoint joinPoint) throws Throwable {
109 ((Loggable) joinPoint.getTarget()).log("before1 ");
110 Object res = joinPoint.proceed();
111 ((Loggable) joinPoint.getTarget()).log("after1 ");
112 return res;
113 }
114
115
116 /***
117 * @Before pc_getFirst(as)
118 */
119 public void getFirstBefore(JoinPoint joinPoint, String as) {
120 ((Loggable) joinPoint.getTarget()).log("before " + as + " ");
121 }
122
123 /***
124 * @After pc_getFirst(as)
125 */
126 public void getFirstAfter(String as, JoinPoint joinPoint) {
127 ((Loggable) joinPoint.getTarget()).log("after " + as + " ");
128 }
129
130 /***
131 * @Around pc_getFirst(as)
132 */
133 public Object getFirstAround(JoinPoint joinPoint, String as) throws Throwable {
134 ((Loggable) joinPoint.getTarget()).log("before1 " + as + " ");
135 Object res = joinPoint.proceed();
136 ((Loggable) joinPoint.getTarget()).log("after1 " + as + " ");
137 return res;
138 }
139
140 /***
141 * @Before in_scope && execution(* getFirstAnonymous(..)) && args(as,String,..)
142 */
143 public void getFirstAnonymousBefore(JoinPoint joinPoint, String as) {
144 ((Loggable) joinPoint.getTarget()).log("before " + as + " ");
145 }
146
147 /***
148 * @After in_scope && execution(* getFirstAnonymous(..)) && args(as, String, long)
149 */
150 public void getFirstAnonymousAfter(String as, JoinPoint joinPoint) {
151 ((Loggable) joinPoint.getTarget()).log("after " + as + " ");
152 }
153
154 /***
155 * @Around in_scope && execution(* getFirstAnonymous(..)) && args(as,..)
156 */
157 public Object getFirstAnonymousAround(JoinPoint joinPoint, String as) throws Throwable {
158 ((Loggable) joinPoint.getTarget()).log("before1 " + as + " ");
159 Object res = joinPoint.proceed();
160 ((Loggable) joinPoint.getTarget()).log("after1 " + as + " ");
161 return res;
162 }
163
164 /***
165 * @Before pc_changeArg(as)
166 */
167 public void changeArgBefore(JoinPoint joinPoint, StringBuffer as) {
168 as.append("x");
169 ((Loggable) joinPoint.getTarget()).log("before " + as.toString() + " ");
170 }
171
172 /***
173 * @After pc_changeArg(as)
174 */
175 public void changeArgAfter(JoinPoint joinPoint, StringBuffer as) {
176 as.append("x");
177 ((Loggable) joinPoint.getTarget()).log("after " + as.toString() + " ");
178 }
179
180 /***
181 * @Around pc_changeArg(as)
182 */
183 public Object changeArgAround(StringBuffer as, JoinPoint joinPoint) throws Throwable {
184 as.append("x");
185 ((Loggable) joinPoint.getTarget()).log("before1 " + as.toString() + " ");
186 Object res = joinPoint.proceed();
187 as.append("x");
188 ((Loggable) joinPoint.getTarget()).log("after1 " + as.toString() + " ");
189 return res;
190 }
191
192
193 /***
194 * @Before pc_orderChangedInPointcutSignature(as0, as1)
195 */
196 public void orderChangedInPointcutSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
197 ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
198 }
199
200 /***
201 * @After pc_orderChangedInPointcutSignature(as0, as1)
202 */
203 public void orderChangedInPointcutSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
204 ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
205 }
206
207 /***
208 * @Around pc_orderChangedInPointcutSignature(as0, as1)
209 */
210 public Object orderChangedInPointcutSignatureAround(JoinPoint joinPoint, String as0, String as1) throws Throwable {
211 ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
212 Object res = joinPoint.proceed();
213 ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
214 return res;
215 }
216
217
218 /***
219 * @Before pc_orderChangedInAdviceSignature(as1, as0)
220 */
221 public void orderChangedInAdviceSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
222 ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
223 }
224
225 /***
226 * @After pc_orderChangedInAdviceSignature(as1, as0)
227 */
228 public void orderChangedInAdviceSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
229 ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
230 }
231
232 /***
233 * @Around pc_orderChangedInAdviceSignature(as1, as0)
234 */
235 public Object orderChangedInAdviceSignatureAround(JoinPoint joinPoint, String as0, String as1) throws Throwable {
236 ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
237 Object res = joinPoint.proceed();
238 ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
239 return res;
240 }
241
242
243 /***
244 * @Before pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
245 */
246 public void orderChangedInPointcutAndAdviceSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
247 ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
248 }
249
250 /***
251 * @After pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
252 */
253 public void orderChangedInPointcutAndAdviceSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
254 ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
255 }
256
257 /***
258 * @Around pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
259 */
260 public Object orderChangedInPointcutAndAdviceSignatureAround(JoinPoint joinPoint, String as0, String as1)
261 throws Throwable {
262 ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
263 Object res = joinPoint.proceed();
264 ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
265 return res;
266 }
267
268
269
270 /***
271 * @Expression in_scope && call(* callGetFirstAndSecond(..)) && args(l, s)
272 */
273 void pc_callGetFirstAndSecond(long l, String[] s) {
274 };
275
276 /***
277 * @Before pc_callGetFirstAndSecond(l, s)
278 */
279 public void callGetFirstAndSecondBefore(JoinPoint joinPoint, long l, String[] s) {
280 ((Loggable) joinPoint.getTarget()).log("before " + l + " " + s[0] + "," + s[1] + " ");
281 }
282
283 /***
284 * @After pc_callGetFirstAndSecond(l, s)
285 */
286 public void callGetFirstAndSecondAfter(JoinPoint joinPoint, long l, String[] s) {
287 ((Loggable) joinPoint.getTarget()).log("after " + l + " " + s[0] + "," + s[1] + " ");
288 }
289
290 /***
291 * @Around pc_callGetFirstAndSecond(l, s)
292 */
293 public Object callGetFirstAndSecondAround(JoinPoint joinPoint, long l, String[] s) throws Throwable {
294 ((Loggable) joinPoint.getTarget()).log("before1 " + l + " " + s[0] + "," + s[1] + " ");
295 Object res = joinPoint.proceed();
296 ((Loggable) joinPoint.getTarget()).log("after1 " + l + " " + s[0] + "," + s[1] + " ");
297 return res;
298 }
299
300
301
302
303 /***
304 * @Expression execution(test.args.ArgsAdviceTest$CtorExecution.new(..)) && args(test.args.ArgsAdviceTest, s)
305 */
306 void pc_ctorExecutionGetFirst(String s) {
307 };
308
309 /***
310 * @Before pc_ctorExecutionGetFirst(s)
311 */
312 public void ctorExecutionGetFirstBefore(JoinPoint joinPoint, String s) {
313 ((Loggable) joinPoint.getTarget()).log("before " + s + " ");
314 }
315
316 /***
317 * @After pc_ctorExecutionGetFirst(s)
318 */
319 public void ctorExecutionGetFirstAfter(JoinPoint joinPoint, String s) {
320 ((Loggable) joinPoint.getTarget()).log("after " + s + " ");
321 }
322
323 /***
324 * @Around pc_ctorExecutionGetFirst(s)
325 */
326 public Object ctorExecutionGetFirstAround(JoinPoint joinPoint, String s) throws Throwable {
327 ((Loggable) joinPoint.getTarget()).log("before1 " + s + " ");
328 Object res = joinPoint.proceed();
329 ((Loggable) joinPoint.getTarget()).log("after1 " + s + " ");
330 return res;
331 }
332
333
334
335
336 /***
337 * @Expression in_scope && call(test.args.ArgsAdviceTest$CtorCall.new(..)) && args(test.args.ArgsAdviceTest, s)
338 */
339 void pc_ctorCallGetFirst(String s) {
340 };
341
342 /***
343 * @Before pc_ctorCallGetFirst(s)
344 */
345 public void ctorCallGetFirstBefore(JoinPoint joinPoint, String s) {
346 ArgsAdviceTest.logStatic("before " + s + " ");
347 }
348
349 /***
350 * @After pc_ctorCallGetFirst(s)
351 */
352 public void ctorCallGetFirstAfter(JoinPoint joinPoint, String s) {
353 ArgsAdviceTest.logStatic("after " + s + " ");
354 }
355
356 /***
357 * @Around pc_ctorCallGetFirst(s)
358 */
359 public Object ctorCallGetFirstAround(JoinPoint joinPoint, String s) throws Throwable {
360 ArgsAdviceTest.logStatic("before1 " + s + " ");
361 Object res = joinPoint.proceed();
362 ArgsAdviceTest.logStatic("after1 " + s + " ");
363 return res;
364 }
365
366
367 /***
368 * @Expression in_scope && set(* m_field) && args(s)
369 */
370 void pc_mfield(String s) {
371 };
372
373 /***
374 * @Before pc_mfield(s)
375 */
376 public void mfieldBefore(JoinPoint joinPoint, String s) {
377 String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
378 ((Loggable) joinPoint.getTarget()).log("before " + fieldValue + "," + s + " ");
379 }
380
381 /***
382 * @After pc_mfield(s)
383 */
384 public void mfieldAfter(JoinPoint joinPoint, String s) {
385 String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
386 ((Loggable) joinPoint.getTarget()).log("after " + fieldValue + "," + s + " ");
387 }
388
389 /***
390 * @Around pc_mfield(s)
391 */
392 public Object mfieldAround(JoinPoint joinPoint, String s) throws Throwable {
393 String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
394 ((Loggable) joinPoint.getTarget()).log("before1 " + fieldValue + "," + s + " ");
395 s = "changed";
396 Object res = joinPoint.proceed();
397 fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
398 ((Loggable) joinPoint.getTarget()).log("after1 " + fieldValue + "," + s + " ");
399 return "ignored";
400 }
401
402
403 /***
404 * @Expression in_scope && set(* s_field) && args(s)
405 */
406 void pc_sfield(String s) {
407 };
408
409 /***
410 * @Before pc_sfield(s)
411 */
412 public void sfieldBefore(JoinPoint joinPoint, String s) {
413 String fieldValue = ArgsAdviceTest.getStaticField();
414 ArgsAdviceTest.logStatic("before " + fieldValue + "," + s + " ");
415 }
416
417 /***
418 * @After pc_sfield(s)
419 */
420 public void sfieldAfter(JoinPoint joinPoint, String s) {
421 String fieldValue = ArgsAdviceTest.getStaticField();
422 ArgsAdviceTest.logStatic("after " + fieldValue + "," + s + " ");
423 }
424
425 /***
426 * @Around pc_sfield(s)
427 */
428 public Object sfieldAround(JoinPoint joinPoint, String s) throws Throwable {
429 String fieldValue = ArgsAdviceTest.getStaticField();
430 ArgsAdviceTest.logStatic("before1 " + fieldValue + "," + s + " ");
431 s = "changed";
432 Object res = joinPoint.proceed();
433 fieldValue = ArgsAdviceTest.getStaticField();
434 ArgsAdviceTest.logStatic("after1 " + fieldValue + "," + s + " ");
435 return "ignored";
436 }
437
438 }