Clover coverage report - dom4j - 1.5
Coverage timestamp: vr sep 3 2004 20:47:03 GMT+01:00
file stats: LOC: 375   Methods: 23
NCLOC: 162   Classes: 3
 
 Source file Conditionals Statements Methods TOTAL
JAXBReader.java 0% 0% 0% 0%
coverage
 1    /*
 2    * Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
 3    *
 4    * This software is open source.
 5    * See the bottom of this file for the licence.
 6    *
 7    * $Id: JAXBReader.java,v 1.1 2004/08/02 18:44:07 maartenc Exp $
 8    */
 9   
 10    package org.dom4j.jaxb;
 11   
 12    import java.io.File;
 13    import java.io.FileInputStream;
 14    import java.io.FileNotFoundException;
 15    import java.io.InputStream;
 16    import java.io.InputStreamReader;
 17    import java.io.Reader;
 18    import java.net.URL;
 19    import java.nio.charset.Charset;
 20   
 21    import org.dom4j.Document;
 22    import org.dom4j.DocumentException;
 23    import org.dom4j.Element;
 24    import org.dom4j.ElementHandler;
 25    import org.dom4j.ElementPath;
 26    import org.dom4j.io.SAXReader;
 27    import org.xml.sax.InputSource;
 28   
 29    /**
 30    * Reads an XML document and creates a DOM4J tree from SAX parsing events.
 31    * {@link JAXBObjectHandler} objects can be registered to automatically receive
 32    * unmarshalled XML fragments.
 33    *
 34    * @see org.dom4j.io.SAXReader
 35    * @see javax.xml.bind.JAXBContext
 36    * @author Wonne Keysers (Realsoftware.be)
 37    */
 38    public class JAXBReader extends JAXBSupport {
 39   
 40    private SAXReader reader;
 41    private boolean pruneElements;
 42   
 43    /**
 44    * Creates a new JAXBReader for the given JAXB context path.
 45    * This is the Java package where JAXB can find the generated XML classes.
 46    * This package MUST contain jaxb.properties!
 47    *
 48    * @param contextPath context path to be used
 49    * @see javax.xml.bind.JAXBContext
 50    */
 51  0 public JAXBReader(String contextPath) {
 52  0 super(contextPath);
 53    }
 54   
 55    /**
 56    * Creates a new JAXBReader for the given JAXB context path,
 57    * using the specified {@link java.lang.Classloader}.
 58    * This is the Java package where JAXB can find the generated XML classes.
 59    * This package MUST contain jaxb.properties!
 60    *
 61    * @param contextPath to be used
 62    * @param classloader to be used
 63    * @see javax.xml.bind.JAXBContext
 64    */
 65  0 public JAXBReader(String contextPath, ClassLoader classloader) {
 66  0 super(contextPath, classloader);
 67    }
 68   
 69    /**
 70    * Parses the specified {@link java.io.File}
 71    *
 72    * @param source the file to parse
 73    * @return the resulting DOM4J document
 74    * @throws DocumentException when an error occurs while parsing
 75    */
 76  0 public Document read(File source) throws DocumentException {
 77  0 return getReader().read(source);
 78    }
 79   
 80    /**
 81    * Parses the specified {@link java.io.File}, using the given {@link java.nio.charset.Charset}.
 82    *
 83    * @param source the file to parse
 84    * @param charset the charset to be used
 85    * @return the resulting DOM4J document
 86    * @throws DocumentException when an error occurs while parsing
 87    */
 88  0 public Document read(File source, Charset charset) throws DocumentException {
 89  0 try {
 90  0 return getReader().read(new InputStreamReader(new FileInputStream(source), charset));
 91    }
 92    catch (JAXBRuntimeException ex) {
 93  0 Throwable cause = ex.getCause();
 94  0 throw new DocumentException(cause.getMessage(), cause);
 95    }
 96    catch (FileNotFoundException ex) {
 97  0 throw new DocumentException(ex.getMessage(), ex);
 98    }
 99    }
 100   
 101    /**
 102    * Parses the specified {@link org.xml.sax.InputSource}
 103    *
 104    * @param source the source to parse
 105    * @return the resulting DOM4J document
 106    * @throws DocumentException when an error occurs while parsing
 107    */
 108  0 public Document read(InputSource source) throws DocumentException {
 109  0 try {
 110  0 return getReader().read(source);
 111    }
 112    catch (JAXBRuntimeException ex) {
 113  0 Throwable cause = ex.getCause();
 114  0 throw new DocumentException(cause.getMessage(), cause);
 115    }
 116    }
 117   
 118    /**
 119    * Parses the specified {@link java.io.InputStream}
 120    *
 121    * @param source the input stream to parse
 122    * @return the resulting DOM4J document
 123    * @throws DocumentException when an error occurs while parsing
 124    */
 125  0 public Document read(InputStream source) throws DocumentException {
 126  0 try {
 127  0 return getReader().read(source);
 128    }
 129    catch (JAXBRuntimeException ex) {
 130  0 Throwable cause = ex.getCause();
 131  0 throw new DocumentException(cause.getMessage(), cause);
 132    }
 133    }
 134   
 135    /**
 136    * Parses the specified {@link java.io.InputStream}
 137    *
 138    * @param source the input stream to parse
 139    * @param systemId is the URI for the input
 140    * @return the resulting DOM4J document
 141    * @throws DocumentException when an error occurs while parsing
 142    */
 143  0 public Document read(InputStream source, String systemId) throws DocumentException {
 144  0 try {
 145  0 return getReader().read(source);
 146    }
 147    catch (JAXBRuntimeException ex) {
 148  0 Throwable cause = ex.getCause();
 149  0 throw new DocumentException(cause.getMessage(), cause);
 150    }
 151    }
 152   
 153    /**
 154    * Parses the specified {@link java.io.Reader}
 155    *
 156    * @param source the input reader to use
 157    * @return the resulting DOM4J document
 158    * @throws DocumentException when an error occurs while parsing
 159    */
 160  0 public Document read(Reader source) throws DocumentException {
 161  0 try {
 162  0 return getReader().read(source);
 163    }
 164    catch (JAXBRuntimeException ex) {
 165  0 Throwable cause = ex.getCause();
 166  0 throw new DocumentException(cause.getMessage(), cause);
 167    }
 168    }
 169   
 170    /**
 171    * Parses the specified {@link java.io.Reader}
 172    *
 173    * @param source the input reader to parse
 174    * @param systemId is the URI for the input
 175    * @return the resulting DOM4J document
 176    * @throws DocumentException when an error occurs while parsing
 177    */
 178  0 public Document read(Reader source, String systemId) throws DocumentException {
 179  0 try {
 180  0 return getReader().read(source);
 181    }
 182    catch (JAXBRuntimeException ex) {
 183  0 Throwable cause = ex.getCause();
 184  0 throw new DocumentException(cause.getMessage(), cause);
 185    }
 186    }
 187   
 188    /**
 189    * Parses the the given URL or filename.
 190    *
 191    * @param source the location to parse
 192    * @return the resulting DOM4J document
 193    * @throws DocumentException when an error occurs while parsing
 194    */
 195  0 public Document read(String source) throws DocumentException {
 196  0 try {
 197  0 return getReader().read(source);
 198    }
 199    catch (JAXBRuntimeException ex) {
 200  0 Throwable cause = ex.getCause();
 201  0 throw new DocumentException(cause.getMessage(), cause);
 202    }
 203    }
 204   
 205    /**
 206    * Parses the the given URL.
 207    *
 208    * @param source the URL to parse
 209    * @return the resulting DOM4J document
 210    * @throws DocumentException when an error occurs while parsing
 211    */
 212  0 public Document read(URL source) throws DocumentException {
 213  0 try {
 214  0 return getReader().read(source);
 215    }
 216    catch (JAXBRuntimeException ex) {
 217  0 Throwable cause = ex.getCause();
 218  0 throw new DocumentException(cause.getMessage(), cause);
 219    }
 220    }
 221   
 222    /**
 223    * Registers a {@link JAXBObjectHandler} that will be supplied with the unmarshalled representation
 224    * of the xml fragment whenever the specified path is encounted.
 225    *
 226    * @param path the path to listen for
 227    * @param handler the handler to be notified
 228    */
 229  0 public void addObjectHandler(String path, JAXBObjectHandler handler) {
 230  0 getReader().addHandler(path, new UnmarshalElementHandler(this, handler));
 231    }
 232   
 233    /**
 234    * Removes the {@link JAXBObjectHandler} from the event based processor,
 235    * for the specified element path.
 236    *
 237    * @param path The path to remove the {@link JAXBObjectHandler} for
 238    */
 239  0 public void removeObjectHandler(String path) {
 240  0 getReader().removeHandler(path);
 241    }
 242   
 243    /**
 244    * Removes all registered {@link JAXBObjectHandler} instances from the event based processor.
 245    */
 246  0 public void resetObjectHandlers() {
 247  0 getReader().resetHandlers();
 248    }
 249   
 250    /**
 251    * When 'true', the DOM4J document will not be kept in memory while parsing.
 252    *
 253    * @return Returns the pruneElements.
 254    */
 255  0 public boolean isPruneElements() {
 256  0 return pruneElements;
 257    }
 258   
 259    /**
 260    * Set to true when DOM4J elements must immediately be pruned from the tree.
 261    * The {@link Document} will not be available afterwards!
 262    *
 263    * @param pruneElements
 264    */
 265  0 public void setPruneElements(boolean pruneElements) {
 266  0 this.pruneElements = pruneElements;
 267  0 if (pruneElements) {
 268  0 getReader().setDefaultHandler(new PruningElementHandler());
 269    }
 270    }
 271   
 272  0 private SAXReader getReader() {
 273  0 if (reader == null) {
 274  0 reader = new SAXReader();
 275    }
 276  0 return reader;
 277    }
 278   
 279    private class UnmarshalElementHandler implements ElementHandler {
 280   
 281    private JAXBReader jaxbReader;
 282    private JAXBObjectHandler handler;
 283   
 284  0 public UnmarshalElementHandler(JAXBReader documentReader, JAXBObjectHandler handler) {
 285  0 this.jaxbReader = documentReader;
 286  0 this.handler = handler;
 287    }
 288   
 289  0 public void onStart(ElementPath elementPath) {
 290    }
 291   
 292  0 public void onEnd(ElementPath elementPath) {
 293  0 try {
 294  0 org.dom4j.Element elem = elementPath.getCurrent();
 295   
 296  0 javax.xml.bind.Element jaxbObject = (javax.xml.bind.Element) jaxbReader.unmarshal(elem);
 297   
 298  0 if (jaxbReader.isPruneElements()) {
 299  0 elem.detach();
 300    }
 301   
 302  0 handler.handleObject(jaxbObject);
 303    }
 304    catch (Exception ex) {
 305  0 throw new JAXBRuntimeException(ex);
 306    }
 307    }
 308   
 309    }
 310   
 311    private class PruningElementHandler implements ElementHandler {
 312   
 313  0 public PruningElementHandler() {
 314    }
 315   
 316  0 public void onStart(ElementPath parm1) {
 317    }
 318   
 319  0 public void onEnd(ElementPath elementPath) {
 320  0 Element elem = elementPath.getCurrent();
 321  0 elem.detach();
 322  0 elem = null;
 323    }
 324   
 325    }
 326   
 327    }
 328   
 329   
 330   
 331   
 332    /*
 333    * Redistribution and use of this software and associated documentation
 334    * ("Software"), with or without modification, are permitted provided
 335    * that the following conditions are met:
 336    *
 337    * 1. Redistributions of source code must retain copyright
 338    * statements and notices. Redistributions must also contain a
 339    * copy of this document.
 340    *
 341    * 2. Redistributions in binary form must reproduce the
 342    * above copyright notice, this list of conditions and the
 343    * following disclaimer in the documentation and/or other
 344    * materials provided with the distribution.
 345    *
 346    * 3. The name "DOM4J" must not be used to endorse or promote
 347    * products derived from this Software without prior written
 348    * permission of MetaStuff, Ltd. For written permission,
 349    * please contact dom4j-info@metastuff.com.
 350    *
 351    * 4. Products derived from this Software may not be called "DOM4J"
 352    * nor may "DOM4J" appear in their names without prior written
 353    * permission of MetaStuff, Ltd. DOM4J is a registered
 354    * trademark of MetaStuff, Ltd.
 355    *
 356    * 5. Due credit should be given to the DOM4J Project -
 357    * http://www.dom4j.org
 358    *
 359    * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS
 360    * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
 361    * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 362    * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 363    * METASTUFF, LTD. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 364    * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 365    * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 366    * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 367    * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 368    * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 369    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 370    * OF THE POSSIBILITY OF SUCH DAMAGE.
 371    *
 372    * Copyright 2001-2004 (C) MetaStuff, Ltd. All Rights Reserved.
 373    *
 374    * $Id: JAXBReader.java,v 1.1 2004/08/02 18:44:07 maartenc Exp $
 375    */