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
 
 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 &quot;faked&quot; <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  
 }