001: /* $Id: FromXmlRuleSet.java 471661 2006-11-06 08:09:25Z skitching $
002: *
003: * Licensed to the Apache Software Foundation (ASF) under one or more
004: * contributor license agreements. See the NOTICE file distributed with
005: * this work for additional information regarding copyright ownership.
006: * The ASF licenses this file to You under the Apache License, Version 2.0
007: * (the "License"); you may not use this file except in compliance with
008: * the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing, software
013: * distributed under the License is distributed on an "AS IS" BASIS,
014: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015: * See the License for the specific language governing permissions and
016: * limitations under the License.
017: */
018:
019: package org.apache.commons.digester.xmlrules;
020:
021: import java.net.URL;
022:
023: import org.apache.commons.digester.Digester;
024: import org.apache.commons.digester.RuleSetBase;
025:
026: import org.xml.sax.InputSource;
027:
028: /**
029: * A Digester rule set where the rules come from an XML file.
030: *
031: * @since 1.2
032: */
033: public class FromXmlRuleSet extends RuleSetBase {
034:
035: public static final String DIGESTER_DTD_PATH = "org/apache/commons/digester/xmlrules/digester-rules.dtd";
036:
037: /**
038: * The file containing the Digester rules, in XML.
039: */
040: private XMLRulesLoader rulesLoader;
041:
042: /**
043: * The rule set for parsing the Digester rules
044: */
045: private DigesterRuleParser parser;
046:
047: /**
048: * The digester for loading the rules xml.
049: */
050: private Digester rulesDigester;
051:
052: /**
053: * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
054: * rulesDigester.
055: * @param rulesXml the path to the XML document defining the Digester rules
056: */
057: public FromXmlRuleSet(URL rulesXml) {
058: this (rulesXml, new DigesterRuleParser(), new Digester());
059: }
060:
061: /**
062: * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
063: * a ruleDigester for loading the rules xml.
064: * @param rulesXml the path to the XML document defining the Digester rules
065: * @param rulesDigester the digester to read the rules xml.
066: */
067: public FromXmlRuleSet(URL rulesXml, Digester rulesDigester) {
068: this (rulesXml, new DigesterRuleParser(), rulesDigester);
069: }
070:
071: /**
072: * @param rulesXml the path to the XML document defining the Digester rules
073: * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
074: */
075: public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser) {
076: this (rulesXml, parser, new Digester());
077: }
078:
079: /**
080: * @param rulesXml the path to the XML document defining the Digester rules
081: * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
082: * @param rulesDigester the digester used to load the Xml rules.
083: */
084: public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser,
085: Digester rulesDigester) {
086: init(new URLXMLRulesLoader(rulesXml), parser, rulesDigester);
087: }
088:
089: /**
090: * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
091: * rulesDigester.
092: * @param inputSource load the xml rules from this InputSource
093: */
094: public FromXmlRuleSet(InputSource inputSource) {
095: this (inputSource, new DigesterRuleParser(), new Digester());
096: }
097:
098: /**
099: * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
100: * a ruleDigester for loading the rules xml.
101: * @param inputSource load the xml rules from this InputSource
102: * @param rulesDigester the digester to read the rules xml.
103: */
104: public FromXmlRuleSet(InputSource inputSource,
105: Digester rulesDigester) {
106: this (inputSource, new DigesterRuleParser(), rulesDigester);
107: }
108:
109: /**
110: * @param inputSource load the xml rules from this InputSource
111: * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
112: */
113: public FromXmlRuleSet(InputSource inputSource,
114: DigesterRuleParser parser) {
115: this (inputSource, parser, new Digester());
116: }
117:
118: /**
119: * @param inputSource load the xml rules from this InputSource
120: * @param parser an instance of DigesterRuleParser, for parsing the rules from XML
121: * @param rulesDigester the digester used to load the Xml rules.
122: */
123: public FromXmlRuleSet(InputSource inputSource,
124: DigesterRuleParser parser, Digester rulesDigester) {
125: init(new InputSourceXMLRulesLoader(inputSource), parser,
126: rulesDigester);
127: }
128:
129: /**
130: * Base constructor
131: */
132: private void init(XMLRulesLoader rulesLoader,
133: DigesterRuleParser parser, Digester rulesDigester) {
134: this .rulesLoader = rulesLoader;
135: this .parser = parser;
136: this .rulesDigester = rulesDigester;
137: }
138:
139: /**
140: * Adds to the digester the set of Rule instances defined in the
141: * XML file for this rule set.
142: * @see org.apache.commons.digester.RuleSetBase
143: */
144: public void addRuleInstances(
145: org.apache.commons.digester.Digester digester)
146: throws XmlLoadException {
147: addRuleInstances(digester, null);
148: }
149:
150: /**
151: * Adds to the digester the set of Rule instances defined in the
152: * XML file for this rule set.
153: * <p>
154: * Note that this method doesn't have a matching one on the DigesterLoader
155: * class, because it is not expected to be widely used, and DigesterLoader's
156: * load method is already heavily overloaded.
157: *
158: * @param digester is the digester that rules will be added to.
159: * @param basePath is a path that will be prefixed to every
160: * pattern string defined in the xmlrules input file.
161: *
162: * @see org.apache.commons.digester.RuleSetBase
163: * @since 1.6
164: */
165: public void addRuleInstances(
166: org.apache.commons.digester.Digester digester,
167: String basePath) throws XmlLoadException {
168:
169: URL dtdURL = getClass().getClassLoader().getResource(
170: DIGESTER_DTD_PATH);
171: if (dtdURL == null) {
172: throw new XmlLoadException("Cannot find resource \""
173: + DIGESTER_DTD_PATH + "\"");
174: }
175: parser.setDigesterRulesDTD(dtdURL.toString());
176: parser.setTarget(digester);
177: parser.setBasePath(basePath);
178:
179: rulesDigester.addRuleSet(parser);
180: rulesDigester.push(parser);
181:
182: rulesLoader.loadRules();
183: }
184:
185: /**
186: * Worker class encapsulates loading mechanisms.
187: * Private until some reason is found to make it public.
188: */
189: private abstract static class XMLRulesLoader {
190: /** Load rules now */
191: public abstract void loadRules() throws XmlLoadException;
192: }
193:
194: /** Loads XMLRules from an URL */
195: private class URLXMLRulesLoader extends XMLRulesLoader {
196: private URL url;
197:
198: public URLXMLRulesLoader(URL url) {
199: this .url = url;
200: }
201:
202: public void loadRules() throws XmlLoadException {
203: try {
204: rulesDigester.parse(url.openStream());
205: } catch (Exception ex) {
206: throw new XmlLoadException(ex);
207: }
208: }
209: }
210:
211: /** Loads XMLRules from an InputSource */
212: private class InputSourceXMLRulesLoader extends XMLRulesLoader {
213: private InputSource inputSource;
214:
215: public InputSourceXMLRulesLoader(InputSource inputSource) {
216: this .inputSource = inputSource;
217: }
218:
219: public void loadRules() throws XmlLoadException {
220: try {
221: rulesDigester.parse(inputSource);
222: } catch (Exception ex) {
223: throw new XmlLoadException(ex);
224: }
225: }
226: }
227: }
|