View Javadoc

1   /*
2    * Copyright 1999-2004 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.chain.config;
17  
18  
19  import org.apache.commons.digester.Digester;
20  import org.apache.commons.digester.RuleSetBase;
21  
22  
23  /***
24   * <p>Digester <code>RuleSet</code> for configuring <em>Chain of
25   * Responsibility</em> command chains, and adding them to an appropriate
26   * {@link Catalog}.  The following properties may be configured prior to
27   * executing the <code>addRuleInstance()</code> method in order to influence
28   * the rules that get added, with default values in square brackets:</p>
29   * <ul>
30   * <li><strong>catalogClass</strong> -- Fully qualified name of the
31   *     implementation class used to create new {@link Catalog} instances.
32   *     If not specified, the default value is
33   *     <code>org.apache.commons.chain.impl.CatalogBsae</code>.</li>
34   * <li><strong>catalogElement</strong> -- Name of the XML element representing
35   *     the addition of a {@link Catalog}.  Any such catalog that is created
36   *     will be registered with the {@link CatalogFactory} instance for our
37   *     application, under the name specified by the <code>nameAttribute</code>
38   *     attribute (if present), or as the default {@link Catalog}.  If not
39   *     specified, the default value is <code>catalog</code>.</li>
40   * <li><strong>chainClass</strong> -- Fully qualified name of the implementation
41   *     class used to create new {@link Chain} instances.  If not specified, the
42   *     default value is <code>org.apache.commons.chain.impl.ChainBase</code>.
43   *     </li>
44   * <li><strong>chainElement</strong> -- Name of the XML element representing
45   *     the addition of a {@link Chain}.  A chain element has the same
46   *     functionality as a command element, except that it defaults the
47   *     implementation class to
48   *     <code>org.apache.commons.chain.impl.ChainBase</code>.  [chain]</li>
49   * <li><strong>classAttribute</strong> -- Attribute on a chain (optional) or
50   *     command (required) element that specifies the fully qualified class
51   *     name of the implementation class that should be instantiated.
52   *     [className]</li>
53   * <li><strong>commandElement</strong> -- Name of the XML element
54   *     representing the addition of a {@link Command}.  An implementation
55   *     class name must be provided on the attribute named by the
56   *     <code>classAttribute</code> property.  [command]</li>
57   * <li><strong>defineElement</strong> -- Name of the XML element
58   *     that associates the element specified by the <code>nameAttribute</code>
59   *     attributes with a {@link Command} or {@link Chain} implementation class
60   *     named by the <code>classAttribute</code> attribute.  [define]</li>
61   * <li><strong>nameAttribute</strong> -- Attribute on an outermost chain or
62   *     command element that will be used to register this command with the
63   *     associated {@link Catalog} instance on the stack.  [name]</li>
64   * <li><strong>namespaceURI</strong> -- The XML namespace URI with which these
65   *     rules will be associated, or <code>null</code> for no namespace.
66   *     [null]</li>
67   * </ul>
68   *
69   * @author Craig R. McClanahan
70   * @version $Revision: 1.9 $ $Date: 2004/11/30 05:52:23 $
71   */
72  
73  public class ConfigRuleSet extends RuleSetBase {
74  
75  
76      // ----------------------------------------------------- Instance Variables
77  
78  
79      private String catalogClass = "org.apache.commons.chain.impl.CatalogBase";
80      private String catalogElement = "catalog";
81      private String chainClass = "org.apache.commons.chain.impl.ChainBase";
82      private String chainElement = "chain";
83      private String classAttribute = "className";
84      private String commandElement = "command";
85      private String defineElement = "define";
86      private String nameAttribute = "name";
87  
88  
89      // ------------------------------------------------------------- Properties
90  
91  
92      /***
93       * <p>Return the fully qualified {@link Catalog} implementation class.</p>
94       */
95      public String getCatalogClass() {
96          return (this.catalogClass);
97      }
98  
99  
100     /***
101      * <p>Set the fully qualified {@link Catalog} implementation class.</p>
102      *
103      * @param catalogClass The new {@link Catalog} implementation class
104      */
105     public void setCatalogClass(String catalogClass) {
106         this.catalogClass = catalogClass;
107     }
108 
109 
110     /***
111      * <p>Return the element name of a catalog element.</p>
112      */
113     public String getCatalogElement() {
114         return (this.catalogElement);
115     }
116 
117 
118     /***
119      * <p>Set the element name of a catalog element.</p>
120      *
121      * @param catalogElement The new element name
122      */
123     public void setCatalogElement(String catalogElement) {
124         this.catalogElement = catalogElement;
125     }
126 
127 
128     /***
129      * <p>Return the fully qualified {@link Chain} implementation class.</p>
130      */
131     public String getChainClass() {
132         return (this.chainClass);
133     }
134 
135 
136     /***
137      * <p>Set the fully qualified {@link Chain} implementation class.</p>
138      *
139      * @param chainClass The new {@link Chain} implementation class
140      */
141     public void setChainClass(String chainClass) {
142         this.chainClass = chainClass;
143     }
144 
145 
146     /***
147      * <p>Return the element name of a chain element.</p>
148      */
149     public String getChainElement() {
150         return (this.chainElement);
151     }
152 
153 
154     /***
155      * <p>Set the element name of a chain element.</p>
156      *
157      * @param chainElement The new element name
158      */
159     public void setChainElement(String chainElement) {
160         this.chainElement = chainElement;
161     }
162 
163 
164     /***
165      * <p>Return the attribute name of a class attribute.</p>
166      */
167     public String getClassAttribute() {
168         return (this.classAttribute);
169     }
170 
171 
172     /***
173      * <p>Set the attribute name of a class attribute.</p>
174      *
175      * @param classAttribute The new attribute name
176      */
177     public void setClassAttribute(String classAttribute) {
178         this.classAttribute = classAttribute;
179     }
180 
181 
182     /***
183      * <p>Return the element name of a command element.</p>
184      */
185     public String getCommandElement() {
186         return (this.commandElement);
187     }
188 
189 
190     /***
191      * <p>Set the element name of a command element.</p>
192      *
193      * @param commandElement The new element name
194      */
195     public void setCommandElement(String commandElement) {
196         this.commandElement = commandElement;
197     }
198 
199 
200     /***
201      * <p>Return the element name of a define element.</p>
202      */
203     public String getDefineElement() {
204         return (this.defineElement);
205     }
206 
207 
208     /***
209      * <p>Set the element name of a define element.</p>
210      *
211      * @param defineElement The new element name
212      */
213     public void setDefineElement(String defineElement) {
214         this.defineElement = defineElement;
215     }
216 
217 
218     /***
219      * <p>Return the attribute name of a name attribute.</p>
220      */
221     public String getNameAttribute() {
222         return (this.nameAttribute);
223     }
224 
225 
226     /***
227      * <p>Set the attribute name of a name attribute.</p>
228      *
229      * @param nameAttribute The new attribute name
230      */
231     public void setNameAttribute(String nameAttribute) {
232         this.nameAttribute = nameAttribute;
233     }
234 
235 
236     // --------------------------------------------------------- Public Methods
237 
238 
239     /***
240      * <p>Add the set of Rule instances defined in this RuleSet to the
241      * specified <code>Digester</code> instance, associating them with
242      * our namespace URI (if any).  This method should only be called
243      * by a Digester instance.</p>
244      *
245      * @param digester Digester instance to which the new Rule instances
246      *  should be added.
247      */
248     public void addRuleInstances(Digester digester) {
249 
250         // Add rules for a catalog element
251         digester.addRule("*/" + getCatalogElement(),
252                          new ConfigCatalogRule(nameAttribute, catalogClass));
253         digester.addSetProperties("*/" + getCatalogElement());
254 
255         // Add rules for a chain element
256         digester.addObjectCreate("*/" + getChainElement(),
257                                  getChainClass(),
258                                  getClassAttribute());
259         digester.addSetProperties("*/" + getChainElement());
260         digester.addRule("*/" + getChainElement(),
261                          new ConfigRegisterRule(nameAttribute));
262 
263         // Add rules for a command element
264         digester.addObjectCreate("*/" + getCommandElement(),
265                                  null,
266                                  getClassAttribute());
267         digester.addSetProperties("*/" + getCommandElement());
268         digester.addRule("*/" + getCommandElement(),
269                          new ConfigRegisterRule(nameAttribute));
270 
271         // Add rules for a define element
272         digester.addRule("*/" + getDefineElement(),
273                          new ConfigDefineRule(getNameAttribute(),
274                                               getClassAttribute()));
275 
276     }
277 
278 
279 }