Coverage Report

Coverage Report - org.apache.commons.configuration.ConfigurationXMLReader

Classes in this File

Line Coverage

Branch Coverage

Complexity

ConfigurationXMLReader

81%

42/52

100%

7/7

1,458

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.commons.configuration;
 
 import java.io.IOException;
 
 import org.xml.sax.Attributes;
 import org.xml.sax.ContentHandler;
 import org.xml.sax.DTDHandler;
 import org.xml.sax.EntityResolver;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.XMLReader;
 import org.xml.sax.helpers.AttributesImpl;
 
 /**
  * <p>A base class for &quot;faked&quot; <code>XMLReader</code> classes
  * that transform a configuration object in a set of SAX parsing events.</p>
  * <p>This class provides dummy implementations for most of the methods
  * defined in the <code>XMLReader</code> interface that are not used for this
  * special purpose. There will be concrete sub classes that process specific
  * configuration classes.</p>
  *
  * @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a>
  * @version $Id: ConfigurationXMLReader.java 439648 2006-09-02 20:42:10Z oheger $
  */
 public abstract class ConfigurationXMLReader implements XMLReader
 {
     /** Constant for the namespace URI.*/
     protected static final String NS_URI = "";
 
     /** Constant for the default name of the root element.*/
     private static final String DEFAULT_ROOT_NAME = "config";
 
     /** An empty attributes object.*/
     private static final Attributes EMPTY_ATTRS = new AttributesImpl();
 
     /** Stores the content handler.*/
     private ContentHandler contentHandler;
 
     /** Stores an exception that occurred during parsing.*/
     private SAXException exception;
 
     /** Stores the name for the root element.*/
     private String rootName;
 
     /**
      * Creates a new instance of <code>ConfigurationXMLReader</code>.
      */
     protected ConfigurationXMLReader()
     {
         super();
         setRootName(DEFAULT_ROOT_NAME);
     }
 
     /**
      * Parses the acutal configuration object. The passed system ID will be
      * ignored.
      *
      * @param systemId the system ID (ignored)
      * @throws IOException if no configuration was specified
      * @throws SAXException if an error occurs during parsing
      */
     public void parse(String systemId) throws IOException, SAXException
     {
         parseConfiguration();
     }
 
     /**
      * Parses the acutal configuration object. The passed input source will be
      * ignored.
      *
      * @param input the input source (ignored)
      * @throws IOException if no configuration was specified
      * @throws SAXException if an error occurs during parsing
      */
     public void parse(InputSource input) throws IOException, SAXException
     {
         parseConfiguration();
     }
 
     /**
      * Dummy implementation of the interface method.
      *
      * @param name the name of the feature
      * @return always <b>false</b> (no features are supported)
      */
     public boolean getFeature(String name)
     {
         return false;
     }
 
     /**
      * Dummy implementation of the interface method.
      *
      * @param name the name of the feature to be set
      * @param value the value of the feature
      */
     public void setFeature(String name, boolean value)
     {
     }
 
     /**
      * Returns the actually set content handler.
      *
      * @return the content handler
      */
     public ContentHandler getContentHandler()
     {
         return contentHandler;
     }
 
     /**
      * Sets the content handler. The object specified here will receive SAX
      * events during parsing.
      *
      * @param handler the content handler
      */
     public void setContentHandler(ContentHandler handler)
     {
         contentHandler = handler;
     }
 
     /**
      * Returns the DTD handler. This class does not support DTD handlers,
      * so this method always returns <b>null</b>.
      *
      * @return the DTD handler
      */
     public DTDHandler getDTDHandler()
     {
         return null;
     }
 
     /**
      * Sets the DTD handler. The passed value is ignored.
      *
      * @param handler the handler to be set
      */
     public void setDTDHandler(DTDHandler handler)
     {
     }
 
     /**
      * Returns the entity resolver. This class does not support an entity
      * resolver, so this method always returns <b>null</b>.
      *
      * @return the entity resolver
      */
     public EntityResolver getEntityResolver()
     {
         return null;
     }
 
     /**
      * Sets the entity resolver. The passed value is ignored.
      *
      * @param resolver the entity resolver
      */
     public void setEntityResolver(EntityResolver resolver)
     {
     }
 
     /**
      * Returns the error handler. This class does not support an error handler,
      * so this method always returns <b>null</b>.
      *
      * @return the error handler
      */
     public ErrorHandler getErrorHandler()
     {
         return null;
     }
 
     /**
      * Sets the error handler. The passed value is ignored.
      *
      * @param handler the error handler
      */
     public void setErrorHandler(ErrorHandler handler)
     {
     }
 
     /**
      * Dummy implementation of the interface method. No properties are
      * supported, so this method always returns <b>null</b>.
      *
      * @param name the name of the requested property
      * @return the property value
      */
     public Object getProperty(String name)
     {
         return null;
     }
 
     /**
      * Dummy implementation of the interface method. No properties are
      * supported, so a call of this method just has no effect.
      *
      * @param name the property name
      * @param value the property value
      */
     public void setProperty(String name, Object value)
     {
     }
 
     /**
      * Returns the name to be used for the root element.
      *
      * @return the name for the root element
      */
     public String getRootName()
     {
         return rootName;
     }
 
     /**
      * Sets the name for the root element.
      *
      * @param string the name for the root element.
      */
     public void setRootName(String string)
     {
         rootName = string;
     }
 
     /**
      * Fires a SAX element start event.
      *
      * @param name the name of the actual element
      * @param attribs the attributes of this element (can be <b>null</b>)
      */
     protected void fireElementStart(String name, Attributes attribs)
     {
         if (getException() == null)
         {
             try
             {
                 Attributes at = (attribs == null) ? EMPTY_ATTRS : attribs;
                 getContentHandler().startElement(NS_URI, name, name, at);
             }
             catch (SAXException ex)
             {
                 exception = ex;
             }
         }
     }
 
     /**
      * Fires a SAX element end event.
      *
      * @param name the name of the affected element
      */
     protected void fireElementEnd(String name)
     {
         if (getException() == null)
         {
             try
             {
                 getContentHandler().endElement(NS_URI, name, name);
             }
             catch (SAXException ex)
             {
                 exception = ex;
             }
         }
     }
 
     /**
      * Fires a SAX characters event.
      *
      * @param text the text
      */
     protected void fireCharacters(String text)
     {
         if (getException() == null)
         {
             try
             {
                 char[] ch = text.toCharArray();
                 getContentHandler().characters(ch, 0, ch.length);
             }
             catch (SAXException ex)
             {
                 exception = ex;
             }
         }
     }
 
     /**
      * Returns a reference to an exception that occurred during parsing.
      *
      * @return a SAXExcpetion or <b>null</b> if none occurred
      */
     public SAXException getException()
     {
         return exception;
     }
 
     /**
      * Parses the configuration object and generates SAX events. This is the
      * main processing method.
      *
      * @throws IOException if no configuration has been specified
      * @throws SAXException if an error occurs during parsing
      */
     protected void parseConfiguration() throws IOException, SAXException
     {
         if (getParsedConfiguration() == null)
         {
             throw new IOException("No configuration specified!");
         }
 
         if (getContentHandler() != null)
         {
             exception = null;
             getContentHandler().startDocument();
             processKeys();
             if (getException() != null)
             {
                 throw getException();
             }
             getContentHandler().endDocument();
         }
     }
 
     /**
      * Returns a reference to the configuration that is parsed by this object.
      *
      * @return the parsed configuration
      */
     public abstract Configuration getParsedConfiguration();
 
     /**
      * Processes all keys stored in the actual configuration. This method is
      * called by <code>parseConfiguration()</code> to start the main parsing
      * process. <code>parseConfiguration()</code> calls the content handler's
      * <code>startDocument()</code> and <code>endElement()</code> methods
      * and cares for exception handling. The remaining actions are left to this
      * method that must be implemented in a concrete sub class.
      *
      * @throws IOException if an IO error occurs
      * @throws SAXException if a SAX error occurs
      */
     protected abstract void processKeys() throws IOException, SAXException;
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		package org.apache.commons.configuration;
19
20		import java.io.IOException;
21
22		import org.xml.sax.Attributes;
23		import org.xml.sax.ContentHandler;
24		import org.xml.sax.DTDHandler;
25		import org.xml.sax.EntityResolver;
26		import org.xml.sax.ErrorHandler;
27		import org.xml.sax.InputSource;
28		import org.xml.sax.SAXException;
29		import org.xml.sax.XMLReader;
30		import org.xml.sax.helpers.AttributesImpl;
31
32		/**
33		* <p>A base class for "faked" <code>XMLReader</code> classes
34		* that transform a configuration object in a set of SAX parsing events.</p>
35		* <p>This class provides dummy implementations for most of the methods
36		* defined in the <code>XMLReader</code> interface that are not used for this
37		* special purpose. There will be concrete sub classes that process specific
38		* configuration classes.</p>
39		*
40		* @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a>
41		* @version $Id: ConfigurationXMLReader.java 439648 2006-09-02 20:42:10Z oheger $
42		*/
43		public abstract class ConfigurationXMLReader implements XMLReader
44		{
45		/** Constant for the namespace URI.*/
46		protected static final String NS_URI = "";
47
48		/** Constant for the default name of the root element.*/
49		private static final String DEFAULT_ROOT_NAME = "config";
50
51		/** An empty attributes object.*/
52	2	private static final Attributes EMPTY_ATTRS = new AttributesImpl();
53
54		/** Stores the content handler.*/
55		private ContentHandler contentHandler;
56
57		/** Stores an exception that occurred during parsing.*/
58		private SAXException exception;
59
60		/** Stores the name for the root element.*/
61		private String rootName;
62
63		/**
64		* Creates a new instance of <code>ConfigurationXMLReader</code>.
65		*/
66		protected ConfigurationXMLReader()
67		{
68	7	super();
69	7	setRootName(DEFAULT_ROOT_NAME);
70	7	}
71
72		/**
73		* Parses the acutal configuration object. The passed system ID will be
74		* ignored.
75		*
76		* @param systemId the system ID (ignored)
77		* @throws IOException if no configuration was specified
78		* @throws SAXException if an error occurs during parsing
79		*/
80		public void parse(String systemId) throws IOException, SAXException
81		{
82	2	parseConfiguration();
83	0	}
84
85		/**
86		* Parses the acutal configuration object. The passed input source will be
87		* ignored.
88		*
89		* @param input the input source (ignored)
90		* @throws IOException if no configuration was specified
91		* @throws SAXException if an error occurs during parsing
92		*/
93		public void parse(InputSource input) throws IOException, SAXException
94		{
95	3	parseConfiguration();
96	3	}
97
98		/**
99		* Dummy implementation of the interface method.
100		*
101		* @param name the name of the feature
102		* @return always <b>false</b> (no features are supported)
103		*/
104		public boolean getFeature(String name)
105		{
106	0	return false;
107		}
108
109		/**
110		* Dummy implementation of the interface method.
111		*
112		* @param name the name of the feature to be set
113		* @param value the value of the feature
114		*/
115		public void setFeature(String name, boolean value)
116		{
117	3	}
118
119		/**
120		* Returns the actually set content handler.
121		*
122		* @return the content handler
123		*/
124		public ContentHandler getContentHandler()
125		{
126	228	return contentHandler;
127		}
128
129		/**
130		* Sets the content handler. The object specified here will receive SAX
131		* events during parsing.
132		*
133		* @param handler the content handler
134		*/
135		public void setContentHandler(ContentHandler handler)
136		{
137	4	contentHandler = handler;
138	4	}
139
140		/**
141		* Returns the DTD handler. This class does not support DTD handlers,
142		* so this method always returns <b>null</b>.
143		*
144		* @return the DTD handler
145		*/
146		public DTDHandler getDTDHandler()
147		{
148	0	return null;
149		}
150
151		/**
152		* Sets the DTD handler. The passed value is ignored.
153		*
154		* @param handler the handler to be set
155		*/
156		public void setDTDHandler(DTDHandler handler)
157		{
158	3	}
159
160		/**
161		* Returns the entity resolver. This class does not support an entity
162		* resolver, so this method always returns <b>null</b>.
163		*
164		* @return the entity resolver
165		*/
166		public EntityResolver getEntityResolver()
167		{
168	0	return null;
169		}
170
171		/**
172		* Sets the entity resolver. The passed value is ignored.
173		*
174		* @param resolver the entity resolver
175		*/
176		public void setEntityResolver(EntityResolver resolver)
177		{
178	0	}
179
180		/**
181		* Returns the error handler. This class does not support an error handler,
182		* so this method always returns <b>null</b>.
183		*
184		* @return the error handler
185		*/
186		public ErrorHandler getErrorHandler()
187		{
188	0	return null;
189		}
190
191		/**
192		* Sets the error handler. The passed value is ignored.
193		*
194		* @param handler the error handler
195		*/
196		public void setErrorHandler(ErrorHandler handler)
197		{
198	0	}
199
200		/**
201		* Dummy implementation of the interface method. No properties are
202		* supported, so this method always returns <b>null</b>.
203		*
204		* @param name the name of the requested property
205		* @return the property value
206		*/
207		public Object getProperty(String name)
208		{
209	0	return null;
210		}
211
212		/**
213		* Dummy implementation of the interface method. No properties are
214		* supported, so a call of this method just has no effect.
215		*
216		* @param name the property name
217		* @param value the property value
218		*/
219		public void setProperty(String name, Object value)
220		{
221	12	}
222
223		/**
224		* Returns the name to be used for the root element.
225		*
226		* @return the name for the root element
227		*/
228		public String getRootName()
229		{
230	8	return rootName;
231		}
232
233		/**
234		* Sets the name for the root element.
235		*
236		* @param string the name for the root element.
237		*/
238		public void setRootName(String string)
239		{
240	8	rootName = string;
241	8	}
242
243		/**
244		* Fires a SAX element start event.
245		*
246		* @param name the name of the actual element
247		* @param attribs the attributes of this element (can be <b>null</b>)
248		*/
249		protected void fireElementStart(String name, Attributes attribs)
250		{
251	101	if (getException() == null)
252		{
253		try
254		{
255	84	Attributes at = (attribs == null) ? EMPTY_ATTRS : attribs;
256	84	getContentHandler().startElement(NS_URI, name, name, at);
257	84	}
258		catch (SAXException ex)
259		{
260	0	exception = ex;
261		}
262		}
263	101	}
264
265		/**
266		* Fires a SAX element end event.
267		*
268		* @param name the name of the affected element
269		*/
270		protected void fireElementEnd(String name)
271		{
272	101	if (getException() == null)
273		{
274		try
275		{
276	80	getContentHandler().endElement(NS_URI, name, name);
277	80	}
278		catch (SAXException ex)
279		{
280	0	exception = ex;
281		}
282		}
283	101	}
284
285		/**
286		* Fires a SAX characters event.
287		*
288		* @param text the text
289		*/
290		protected void fireCharacters(String text)
291		{
292	67	if (getException() == null)
293		{
294		try
295		{
296	53	char[] ch = text.toCharArray();
297	53	getContentHandler().characters(ch, 0, ch.length);
298	52	}
299		catch (SAXException ex)
300		{
301	1	exception = ex;
302		}
303		}
304	67	}
305
306		/**
307		* Returns a reference to an exception that occurred during parsing.
308		*
309		* @return a SAXExcpetion or <b>null</b> if none occurred
310		*/
311		public SAXException getException()
312		{
313	313	return exception;
314		}
315
316		/**
317		* Parses the configuration object and generates SAX events. This is the
318		* main processing method.
319		*
320		* @throws IOException if no configuration has been specified
321		* @throws SAXException if an error occurs during parsing
322		*/
323		protected void parseConfiguration() throws IOException, SAXException
324		{
325	5	if (getParsedConfiguration() == null)
326		{
327	1	throw new IOException("No configuration specified!");
328		}
329
330	4	if (getContentHandler() != null)
331		{
332	4	exception = null;
333	4	getContentHandler().startDocument();
334	4	processKeys();
335	4	if (getException() != null)
336		{
337	1	throw getException();
338		}
339	3	getContentHandler().endDocument();
340		}
341	3	}
342
343		/**
344		* Returns a reference to the configuration that is parsed by this object.
345		*
346		* @return the parsed configuration
347		*/
348		public abstract Configuration getParsedConfiguration();
349
350		/**
351		* Processes all keys stored in the actual configuration. This method is
352		* called by <code>parseConfiguration()</code> to start the main parsing
353		* process. <code>parseConfiguration()</code> calls the content handler's
354		* <code>startDocument()</code> and <code>endElement()</code> methods
355		* and cares for exception handling. The remaining actions are left to this
356		* method that must be implemented in a concrete sub class.
357		*
358		* @throws IOException if an IO error occurs
359		* @throws SAXException if a SAX error occurs
360		*/
361		protected abstract void processKeys() throws IOException, SAXException;
362		}