KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nanocontainer > aop > dynaop > DynaopPointcutsFactory


1 /*****************************************************************************
2  * Copyright (c) PicoContainer Organization. All rights reserved. *
3  * ------------------------------------------------------------------------- *
4  * The software in this package is published under the terms of the BSD *
5  * style license a copy of which has been included with this distribution in *
6  * the LICENSE.txt file. *
7  * *
8  * Idea by Rachel Davies, Original code by various *
9  *****************************************************************************/
10 package org.nanocontainer.aop.dynaop;
11
12 import dynaop.Pointcuts;
13 import org.apache.oro.text.regex.MalformedPatternException;
14 import org.nanocontainer.aop.ClassPointcut;
15 import org.nanocontainer.aop.MalformedRegularExpressionException;
16 import org.nanocontainer.aop.MethodPointcut;
17 import org.nanocontainer.aop.defaults.AbstractPointcutsFactory;
18
19 import java.lang.reflect.Method JavaDoc;
20
21 /**
22  * Implements the <code>org.nanocontainer.aop.PointcutsFactory</code>
23  * interface using dynaop.
24  *
25  * @author Stephen Molitor
26  * @version $Revision: 3144 $
27  */
28 public class DynaopPointcutsFactory extends AbstractPointcutsFactory {
29
30     public ClassPointcut allClasses() {
31         return new DynaopClassPointcut(Pointcuts.ALL_CLASSES);
32     }
33
34     public ClassPointcut instancesOf(Class JavaDoc type) {
35         return new DynaopClassPointcut(Pointcuts.instancesOf(type));
36     }
37
38     public ClassPointcut className(String JavaDoc regex) {
39         try {
40             return new DynaopClassPointcut(Pointcuts.className(regex));
41         } catch (MalformedPatternException e) {
42             throw new MalformedRegularExpressionException("malformed class name regular expression", e);
43         }
44     }
45
46     public ClassPointcut oneClass(Class JavaDoc clazz) {
47         return new DynaopClassPointcut(Pointcuts.singleton(clazz));
48     }
49
50     public ClassPointcut packageName(String JavaDoc packageName) {
51         return new DynaopClassPointcut(Pointcuts.packageName(packageName));
52     }
53
54     public ClassPointcut intersection(ClassPointcut a, ClassPointcut b) {
55         return new DynaopClassPointcut(Pointcuts.intersection(toDynaopClassCut(a), toDynaopClassCut(b)));
56     }
57
58     public ClassPointcut union(ClassPointcut a, ClassPointcut b) {
59         return new DynaopClassPointcut(Pointcuts.union(toDynaopClassCut(a), toDynaopClassCut(b)));
60     }
61
62     public ClassPointcut not(ClassPointcut classPointcut) {
63         return new DynaopClassPointcut(Pointcuts.not(toDynaopClassCut(classPointcut)));
64     }
65
66     public MethodPointcut allMethods() {
67         return new DynaopMethodPointcut(Pointcuts.ALL_METHODS);
68     }
69
70     public MethodPointcut getMethods() {
71         return new DynaopMethodPointcut(Pointcuts.GET_METHODS);
72     }
73
74     public MethodPointcut isMethods() {
75         return new DynaopMethodPointcut(Pointcuts.IS_METHODS);
76     }
77
78     public MethodPointcut setMethods() {
79         return new DynaopMethodPointcut(Pointcuts.SET_METHODS);
80     }
81
82     public MethodPointcut objectMethods() {
83         return new DynaopMethodPointcut(Pointcuts.OBJECT_METHODS);
84     }
85
86     public MethodPointcut returnType(ClassPointcut classPointcut) {
87         return new DynaopMethodPointcut(Pointcuts.returnType(toDynaopClassCut(classPointcut)));
88     }
89
90     public MethodPointcut signature(String JavaDoc regexp) {
91         try {
92             return new DynaopMethodPointcut(Pointcuts.signature(regexp));
93         } catch (MalformedPatternException e) {
94             throw new MalformedRegularExpressionException("malformed method signature regular expression", e);
95         }
96     }
97
98     public MethodPointcut oneMethod(Method JavaDoc method) {
99         return new DynaopMethodPointcut(Pointcuts.singleton(method));
100     }
101
102     public MethodPointcut declaringClass(ClassPointcut classPointcut) {
103         return new DynaopMethodPointcut(Pointcuts.declaringClass(toDynaopClassCut(classPointcut)));
104     }
105
106     public MethodPointcut membersOf(Class JavaDoc clazz) {
107         return new DynaopMethodPointcut(Pointcuts.membersOf(clazz));
108     }
109
110     public MethodPointcut intersection(MethodPointcut a, MethodPointcut b) {
111         return new DynaopMethodPointcut(Pointcuts.intersection(toDynaopMethodCut(a), toDynaopMethodCut(b)));
112     }
113
114     public MethodPointcut union(MethodPointcut a, MethodPointcut b) {
115         return new DynaopMethodPointcut(Pointcuts.union(toDynaopMethodCut(a), toDynaopMethodCut(b)));
116     }
117
118     public MethodPointcut not(MethodPointcut methodPointcut) {
119         return new DynaopMethodPointcut(Pointcuts.not(toDynaopMethodCut(methodPointcut)));
120     }
121
122     private static dynaop.ClassPointcut toDynaopClassCut(final ClassPointcut nanoCut) {
123         // The purpose of the anonymous inner class adapter below is to allow
124 // users to use union, intersection and not with custom pointcuts (not
125 // instances of dynaop.ClassPointcut). Now we could just wrap nanoCut
126 // with the adapter every time, even if it is already a
127 // dynaop.ClassPointcut. But the extra level of indirection gets a
128 // little
129 // confusing when debugging. Thus the instanceof check.
130 if (nanoCut instanceof dynaop.ClassPointcut) {
131             return (dynaop.ClassPointcut) nanoCut;
132         } else {
133             return new dynaop.ClassPointcut() {
134                 public boolean picks(Class JavaDoc clazz) {
135                     return nanoCut.picks(clazz);
136                 }
137             };
138         }
139     }
140
141     private static dynaop.MethodPointcut toDynaopMethodCut(final MethodPointcut nanoCut) {
142         // see comment in toDynaopClassCut, above
143 if (nanoCut instanceof dynaop.MethodPointcut) {
144             return (dynaop.MethodPointcut) nanoCut;
145         } else {
146             return new dynaop.MethodPointcut() {
147                 public boolean picks(Method JavaDoc method) {
148                     return nanoCut.picks(method);
149                 }
150             };
151         }
152     }
153
154 }
Popular Tags