View Javadoc

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 java.util.ArrayList;
11  import java.util.Collection;
12  import java.util.HashMap;
13  import java.util.List;
14  import java.util.Map;
15  
16  import org.codehaus.aspectwerkz.reflect.ClassInfo;
17  import org.codehaus.aspectwerkz.DeploymentModel;
18  import org.codehaus.aspectwerkz.DeploymentModel;
19  import org.codehaus.aspectwerkz.aspect.DefaultAspectContainerStrategy;
20  
21  /***
22   * Holds the meta-data for the aspect.
23   *
24   * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr </a>
25   * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur </a>
26   */
27  public class AspectDefinition {
28  
29      private final static String DEFAULT_ASPECTCONTAINER_CLASSNAME = DefaultAspectContainerStrategy.class.getName();
30  
31      /***
32       * The default aspectwerkz aspect model type id.
33       */
34      public static final String ASPECTWERKZ_ASPECT_MODEL_TYPE = "aspectwerkz";
35  
36      /***
37       * The name of the aspect (nickname).
38       */
39      private String m_name;
40  
41      /***
42       * The nickname of the aspect prefixed by the <system uuid>/
43       */
44      private String m_qualifiedName;
45  
46      /***
47       * The aspect class info.
48       */
49      private final ClassInfo m_classInfo;
50  
51      /***
52       * The deployment model for the aspect.
53       */
54      private DeploymentModel m_deploymentModel = DeploymentModel.PER_JVM;
55  
56      /***
57       * The around advices.
58       */
59      private final List m_aroundAdviceDefinitions = new ArrayList();
60  
61      /***
62       * The before advices.
63       */
64      private final List m_beforeAdviceDefinitions = new ArrayList();
65  
66      /***
67       * The after advices.
68       */
69      private final List m_afterAdviceDefinitions = new ArrayList();
70  
71      /***
72       * The interface introductions (pure interfaces)
73       */
74      private final List m_interfaceIntroductionDefinitions = new ArrayList();
75  
76      /***
77       * The pointcuts.
78       */
79      private final List m_pointcutDefinitions = new ArrayList();
80  
81      /***
82       * The parameters passed to the aspect at definition time.
83       */
84      private Map m_parameters = new HashMap();
85  
86      /***
87       * The container implementation class name.
88       */
89      private String m_containerClassName;
90  
91      /***
92       * The system definition.
93       */
94      private SystemDefinition m_systemDefinition;
95  
96      /***
97       * The aspect model.
98       */
99      private String m_aspectModelType = ASPECTWERKZ_ASPECT_MODEL_TYPE;
100 
101     /***
102      * Creates a new aspect meta-data instance.
103      *
104      * @param name             the name of the aspect
105      * @param classInfo        the class info for the aspect
106      * @param systemDefinition
107      */
108     public AspectDefinition(final String name, final ClassInfo classInfo, final SystemDefinition systemDefinition) {
109         if (name == null) {
110             throw new IllegalArgumentException("aspect name can not be null");
111         }
112         if (classInfo == null) {
113             throw new IllegalArgumentException("aspect class info can not be null");
114         }
115         m_name = name;
116         m_classInfo = classInfo;
117         m_systemDefinition = systemDefinition;
118         m_qualifiedName = systemDefinition.getUuid() + '/' + name;
119 
120         // default container
121         setContainerClassName(DEFAULT_ASPECTCONTAINER_CLASSNAME);
122     }
123 
124     /***
125      * Returns the name for the advice
126      *
127      * @return the name
128      */
129     public String getName() {
130         return m_name;
131     }
132 
133     /***
134      * Sets the name for the aspect.
135      *
136      * @param name the name
137      */
138     public void setName(final String name) {
139         m_name = name.trim();
140     }
141 
142     /***
143      * Returns the fully qualified name for the advice
144      *
145      * @return the fully qualified name
146      */
147     public String getQualifiedName() {
148         return m_qualifiedName;
149     }
150 
151     /***
152      * Returns the system definition.
153      *
154      * @return
155      */
156     public SystemDefinition getSystemDefinition() {
157         return m_systemDefinition;
158     }
159 
160     /***
161      * Returns the class name.
162      *
163      * @return the class name
164      */
165     public String getClassName() {
166         return m_classInfo.getName();
167     }
168 
169     /***
170      * Returns the class info.
171      *
172      * @return the class info
173      */
174     public ClassInfo getClassInfo() {
175         return m_classInfo;
176     }
177 
178     /***
179      * Returns the aspect model.
180      *
181      * @return the aspect model
182      */
183     public String getAspectModel() {
184         return m_aspectModelType;
185     }
186 
187     /***
188      * Checks if the aspect defined is an AspectWerkz aspect.
189      *
190      * @return
191      */
192     public boolean isAspectWerkzAspect() {
193         return m_aspectModelType.equals(ASPECTWERKZ_ASPECT_MODEL_TYPE);
194     }
195 
196     /***
197      * Sets the aspect model.
198      *
199      * @param aspectModelType the aspect model
200      */
201     public void setAspectModel(final String aspectModelType) {
202         m_aspectModelType = aspectModelType;
203     }
204 
205     /***
206      * Sets the deployment model.
207      *
208      * @param deploymentModel the deployment model
209      */
210     public void setDeploymentModel(final DeploymentModel deploymentModel) {
211         m_deploymentModel = deploymentModel;
212     }
213 
214     /***
215      * Returns the deployment model.
216      *
217      * @return the deployment model
218      */
219     public DeploymentModel getDeploymentModel() {
220         return m_deploymentModel;
221     }
222 
223     /***
224      * Adds a new around advice.
225      *
226      * @param adviceDef the around advice
227      */
228     public void addAroundAdviceDefinition(final AdviceDefinition adviceDef) {
229         if (!m_aroundAdviceDefinitions.contains(adviceDef)) {
230             m_aroundAdviceDefinitions.add(adviceDef);
231         }
232     }
233 
234     /***
235      * Returns the around advices.
236      *
237      * @return the around advices
238      */
239     public List getAroundAdviceDefinitions() {
240         return m_aroundAdviceDefinitions;
241     }
242 
243     /***
244      * Adds a new before advice.
245      *
246      * @param adviceDef the before advice
247      */
248     public void addBeforeAdviceDefinition(final AdviceDefinition adviceDef) {
249         if (!m_beforeAdviceDefinitions.contains(adviceDef)) {
250             m_beforeAdviceDefinitions.add(adviceDef);
251         }
252     }
253 
254     /***
255      * Returns the before advices.
256      *
257      * @return the before advices
258      */
259     public List getBeforeAdviceDefinitions() {
260         return m_beforeAdviceDefinitions;
261     }
262 
263     /***
264      * Adds a new after advice.
265      *
266      * @param adviceDef the after advice
267      */
268     public void addAfterAdviceDefinition(final AdviceDefinition adviceDef) {
269         if (!m_afterAdviceDefinitions.contains(adviceDef)) {
270             m_afterAdviceDefinitions.add(adviceDef);
271         }
272     }
273 
274     /***
275      * Returns the after advices.
276      *
277      * @return the after advices
278      */
279     public List getAfterAdviceDefinitions() {
280         return m_afterAdviceDefinitions;
281     }
282 
283     /***
284      * Adds a new pure interface introduction.
285      *
286      * @param interfaceIntroDef the introduction
287      */
288     public void addInterfaceIntroductionDefinition(final InterfaceIntroductionDefinition interfaceIntroDef) {
289         m_interfaceIntroductionDefinitions.add(interfaceIntroDef);
290     }
291 
292     /***
293      * Returns the interface introductions.
294      *
295      * @return the introductions
296      */
297     public List getInterfaceIntroductionDefinitions() {
298         return m_interfaceIntroductionDefinitions;
299     }
300 
301     /***
302      * Adds a new pointcut definition.
303      *
304      * @param pointcutDef the pointcut definition
305      */
306     public void addPointcutDefinition(final PointcutDefinition pointcutDef) {
307         m_pointcutDefinitions.add(pointcutDef);
308     }
309 
310     /***
311      * Returns the pointcuts.
312      *
313      * @return the pointcuts
314      */
315     public Collection getPointcutDefinitions() {
316         return m_pointcutDefinitions;
317     }
318 
319     /***
320      * Adds a new parameter to the advice.
321      *
322      * @param name  the name of the parameter
323      * @param value the value for the parameter
324      */
325     public void addParameter(final String name, final String value) {
326         m_parameters.put(name, value);
327     }
328 
329     /***
330      * Returns the parameters as a Map.
331      *
332      * @return the parameters
333      */
334     public Map getParameters() {
335         return m_parameters;
336     }
337 
338     /***
339      * Sets the name of the container implementation class.
340      *
341      * @param containerClassName the container class name
342      */
343     public void setContainerClassName(final String containerClassName) {
344         if (containerClassName != null) {
345             m_containerClassName = containerClassName.replace('/', '.');
346         }
347     }
348 
349     /***
350      * Returns the name of the container implementation class.
351      *
352      * @return the container class name
353      */
354     public String getContainerClassName() {
355         return m_containerClassName;
356     }
357 
358     /***
359      * Returns all the advices for this aspect.
360      *
361      * @return all the advices
362      */
363     public List getAdviceDefinitions() {
364         final List allAdvices = new ArrayList();
365         allAdvices.addAll(m_aroundAdviceDefinitions);
366         allAdvices.addAll(m_beforeAdviceDefinitions);
367         allAdvices.addAll(m_afterAdviceDefinitions);
368         return allAdvices;
369     }
370 }