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.expression;
9   
10  import org.codehaus.aspectwerkz.exception.DefinitionException;
11  
12  import java.util.HashMap;
13  import java.util.Map;
14  import java.util.WeakHashMap;
15  
16  /***
17   * The expression namespace as well as a repository for the namespaces. <p/>A namespace is usually defined by the name
18   * of the class defining the expression.
19   *
20   * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr </a>
21   */
22  public final class ExpressionNamespace {
23      /***
24       * Namespace container.
25       */
26      private static final Map s_namespaces = new WeakHashMap();
27  
28      /***
29       * Map with all the expressions in the namespace, [name:expression] pairs.
30       */
31      private final Map m_expressions = new HashMap();
32  
33      /***
34       * The namespace.
35       */
36      private final String m_namespace;
37  
38      /***
39       * Creates a new expression namespace.
40       *
41       * @param namespace
42       */
43      private ExpressionNamespace(final String namespace) {
44          m_namespace = namespace;
45      }
46  
47      /***
48       * Returns the expression namespace for a specific namespace.
49       *
50       * @param namespace the expression namespace
51       * @return the expression namespace abstraction
52       */
53      public static synchronized ExpressionNamespace getNamespace(final String namespace) {
54          if (!s_namespaces.containsKey(namespace)) {
55              s_namespaces.put(namespace, new ExpressionNamespace(namespace));
56          }
57          return (ExpressionNamespace) s_namespaces.get(namespace);
58      }
59  
60      /***
61       * Adds an expression info to the namespace.
62       *
63       * @param name           the name mapped to the expression
64       * @param expressionInfo the expression info to add
65       */
66      public void addExpressionInfo(final String name, final ExpressionInfo expressionInfo) {
67          m_expressions.put(name, expressionInfo);
68      }
69  
70      /***
71       * Returns the expression info with a specific name or null if it could not be found.
72       *
73       * @param name the name of the expression
74       * @return the expression info
75       */
76      public ExpressionInfo getExpressionInfoOrNull(final String name) {
77          int index = name.lastIndexOf('.');
78          if (index != -1) {
79              // stay in the same CflowStack
80              //TODO: allow for lookup in other CflowStack providing they are in the same hierarchy
81              return getNamespace(name.substring(0, index)).getExpressionInfoOrNull(
82                      name.substring(index + 1, name.length())
83              );
84          } else {
85              final ExpressionInfo expressionInfo = ((ExpressionInfo) m_expressions.get(name));
86  //            if (expressionInfo == null) {
87  //                throw new DefinitionException(
88  //                        new StringBuffer().
89  //                        append("could not resolve reference to pointcut [").
90  //                        append(name).
91  //                        append("] in namespace [").
92  //                        append(m_namespace).
93  //                        append("]").toString()
94  //                );
95  //            }
96              return expressionInfo;
97          }
98      }
99  
100     /***
101      * Returns the expression info with a specific name or throw an exception if it could not be found.
102      *
103      * @param name the name of the expression
104      * @return the expression info
105      */
106     public ExpressionInfo getExpressionInfo(final String name) {
107         int index = name.lastIndexOf('.');
108         if (index != -1) {
109             // stay in the same CflowStack
110             //TODO: allow for lookup in other CflowStack providing they are in the same hierarchy
111             return getNamespace(name.substring(0, index)).getExpressionInfo(name.substring(index + 1, name.length()));
112         } else {
113             final ExpressionInfo expressionInfo = ((ExpressionInfo) m_expressions.get(name));
114             if (expressionInfo == null) {
115                 throw new DefinitionException(
116                         new StringBuffer().
117                         append("could not resolve reference to pointcut [").
118                         append(name).
119                         append("] in namespace [").
120                         append(m_namespace).
121                         append("]").toString()
122                 );
123             }
124             return expressionInfo;
125         }
126     }
127 
128     /***
129      * Returns the expression with a specific name.
130      *
131      * @param name the name of the expression
132      * @return the expression
133      */
134     public ExpressionVisitor getExpression(final String name) {
135         return getExpressionInfo(name).getExpression();
136     }
137 
138     /***
139      * Returns the advised class expression with a specific name.
140      *
141      * @param name the name of the expression
142      * @return the expression
143      */
144     public AdvisedClassFilterExpressionVisitor getAdvisedClassExpression(final String name) {
145         return getExpressionInfo(name).getAdvisedClassFilterExpression();
146     }
147 
148     /***
149      * Returns the name of the namespace.
150      *
151      * @return the name of the namespace
152      */
153     public String getName() {
154         return m_namespace;
155     }
156 }