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 org.codehaus.aspectwerkz.definition;
9
10 import org.codehaus.aspectwerkz.MethodComparator;
11
12 import java.util.ArrayList;
13 import java.util.Collection;
14 import java.util.Collections;
15 import java.util.Comparator;
16 import java.util.HashMap;
17 import java.util.List;
18 import java.util.Map;
19
20 /***
21 * Holds the meta-data for the aspect.
22 *
23 * @author <a href="mailto:jboner@codehaus.org">Jonas Bonér </a>
24 * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur </a>
25 */
26 public class AspectDefinition {
27 /***
28 * The name of the aspect.
29 */
30 private String m_name;
31
32 /***
33 * The name of the aspect prefixed by the system uuid
34 */
35 private String m_fullQualifiedName;
36
37 /***
38 * The aspect class name.
39 */
40 private final String m_className;
41
42 /***
43 * The deployment model for the aspect.
44 */
45 private String m_deploymentModel = "perJVM";
46
47 /***
48 * The around advices.
49 */
50 private final List m_aroundAdvices = new ArrayList();
51
52 /***
53 * The before advices.
54 */
55 private final List m_beforeAdvices = new ArrayList();
56
57 /***
58 * The after advices.
59 */
60 private final List m_afterAdvices = new ArrayList();
61
62 /***
63 * The interface introductions (pure interfaces)
64 */
65 private final List m_interfaceIntroductions = new ArrayList();
66
67 /***
68 * The pointcuts definitions. The implementation introductions
69 */
70 private final List m_introductions = new ArrayList();
71
72 /***
73 * The pointcuts.
74 */
75 private final List m_pointcutDefs = new ArrayList();
76
77 /***
78 * The parameters passed to the advice at definition time.
79 */
80 private Map m_parameters = new HashMap();
81
82 /***
83 * The container implementation class name.
84 */
85 private String m_containerClassName;
86
87 /***
88 * Creates a new aspect meta-data instance.
89 *
90 * @param name the name of the aspect
91 * @param className the class name of the aspect
92 */
93 public AspectDefinition(final String name, final String className, final String uuid) {
94 if (name == null) {
95 throw new IllegalArgumentException("aspect name can not be null");
96 }
97 if (className == null) {
98 throw new IllegalArgumentException("aspect class name can not be null");
99 }
100 m_name = name;
101 m_className = className;
102 m_fullQualifiedName = uuid + "/" + name;
103 }
104
105 /***
106 * Returns the pattern for the aspect
107 *
108 * @return the pattern
109 */
110 public String getName() {
111 return m_name;
112 }
113
114 /***
115 * Returns the pattern for the aspect
116 *
117 * @return the pattern
118 */
119 public String getFullQualifiedName() {
120 return m_fullQualifiedName;
121 }
122
123 /***
124 * Sets the name for the aspect.
125 *
126 * @param name the name
127 */
128 public void setName(final String name) {
129 m_name = name.trim();
130 }
131
132 /***
133 * Returns the class name.
134 *
135 * @return the class name
136 */
137 public String getClassName() {
138 return m_className;
139 }
140
141 /***
142 * Sets the deployment model.
143 *
144 * @param deploymentModel the deployment model
145 */
146 public void setDeploymentModel(final String deploymentModel) {
147 m_deploymentModel = deploymentModel;
148 }
149
150 /***
151 * Returns the deployment model.
152 *
153 * @return the deployment model
154 */
155 public String getDeploymentModel() {
156 return m_deploymentModel;
157 }
158
159 /***
160 * Adds a new around advice.
161 *
162 * @param adviceMetaData the around advice
163 */
164 public void addAroundAdvice(final AdviceDefinition adviceMetaData) {
165 m_aroundAdvices.add(adviceMetaData);
166 }
167
168 /***
169 * Remove an around advice. Experimental
170 *
171 * @param adviceMetaData the around advice
172 */
173 public void removeAroundAdvice(final AdviceDefinition adviceMetaData) {
174 m_aroundAdvices.remove(adviceMetaData);
175 }
176
177 /***
178 * Returns the around advices.
179 *
180 * @return the around advices
181 */
182 public List getAroundAdvices() {
183 return m_aroundAdvices;
184 }
185
186 /***
187 * Adds a new before advice.
188 *
189 * @param adviceMetaData the before advice
190 */
191 public void addBeforeAdvice(final AdviceDefinition adviceMetaData) {
192 m_beforeAdvices.add(adviceMetaData);
193 }
194
195 /***
196 * Returns the before advices.
197 *
198 * @return the before advices
199 */
200 public List getBeforeAdvices() {
201 return m_beforeAdvices;
202 }
203
204 /***
205 * Adds a new after advice.
206 *
207 * @param adviceMetaData the after advice
208 */
209 public void addAfterAdvice(final AdviceDefinition adviceMetaData) {
210 m_afterAdvices.add(adviceMetaData);
211 }
212
213 /***
214 * Returns the after advices.
215 *
216 * @return the after advices
217 */
218 public List getAfterAdvices() {
219 return m_afterAdvices;
220 }
221
222 /***
223 * Adds a new pure interface introduction.
224 *
225 * @param interfaceIntroductionMetaData the introduction
226 */
227 public void addInterfaceIntroduction(final InterfaceIntroductionDefinition interfaceIntroductionMetaData) {
228 m_interfaceIntroductions.add(interfaceIntroductionMetaData);
229 }
230
231 /***
232 * Adds a new implementation introduction.
233 *
234 * @param introductionMetaData the introduction
235 */
236 public void addIntroduction(final IntroductionDefinition introductionMetaData) {
237 m_introductions.add(introductionMetaData);
238 }
239
240 /***
241 * Returns the interface introductions.
242 *
243 * @return the introductions
244 */
245 public List getInterfaceIntroductions() {
246 return m_interfaceIntroductions;
247 }
248
249 /***
250 * Returns the implementation introductions.
251 *
252 * @return the introductions
253 */
254 public List getIntroductions() {
255 return m_introductions;
256 }
257
258 /***
259 * Adds a new pointcut definition.
260 *
261 * @param pointcutDef the pointcut definition
262 */
263 public void addPointcut(final PointcutDefinition pointcutDef) {
264 m_pointcutDefs.add(pointcutDef);
265 }
266
267 /***
268 * Returns the pointcuts.
269 *
270 * @return the pointcuts
271 */
272 public Collection getPointcuts() {
273 return m_pointcutDefs;
274 }
275
276 /***
277 * Adds a new parameter to the advice.
278 *
279 * @param name the name of the parameter
280 * @param value the value for the parameter
281 */
282 public void addParameter(final String name, final String value) {
283 m_parameters.put(name, value);
284 }
285
286 /***
287 * Returns the parameters as a Map.
288 *
289 * @return the parameters
290 */
291 public Map getParameters() {
292 return m_parameters;
293 }
294
295 /***
296 * Sets the name of the container implementation class.
297 *
298 * @param containerClassName the container class name
299 */
300 public void setContainerClassName(final String containerClassName) {
301 m_containerClassName = containerClassName;
302 }
303
304 /***
305 * Returns the name of the container implementation class.
306 *
307 * @return the container class name
308 */
309 public String getContainerClassName() {
310 return m_containerClassName;
311 }
312
313 /***
314 * Returns all the advices for this aspect.
315 *
316 * @return all the advices
317 * @TODO: gets sorted every time, have a flag?
318 */
319 public List getAllAdvices() {
320 final List allAdvices = new ArrayList();
321 allAdvices.addAll(m_aroundAdvices);
322 allAdvices.addAll(m_beforeAdvices);
323 allAdvices.addAll(m_afterAdvices);
324 return sortAdvices(allAdvices);
325 }
326
327 /***
328 * Sorts the advice by method.
329 *
330 * @param advices a list with the advices to sort
331 * @return a sorted list with the advices
332 */
333 public static List sortAdvices(final List advices) {
334 Collections.sort(advices, new Comparator() {
335 private Comparator m_comparator = MethodComparator.getInstance(MethodComparator.NORMAL_METHOD);
336
337 public int compare(final Object obj1, final Object obj2) {
338 AdviceDefinition advice1 = (AdviceDefinition) obj1;
339 AdviceDefinition advice2 = (AdviceDefinition) obj2;
340 return m_comparator.compare(advice1.getMethod(), advice2.getMethod());
341 }
342 });
343 return advices;
344 }
345 }