Clover coverage report - dom4j - 1.6.1
Coverage timestamp: ma mei 16 2005 14:23:01 GMT+01:00
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 685   Methods: 42
NCLOC: 242   Classes: 3
 
 Source file Conditionals Statements Methods TOTAL
STAXEventWriter.java 75% 34% 38,1% 36,2%
coverage coverage
 1    /*
 2    * Copyright 2001-2005 (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   
 8    package org.dom4j.io;
 9   
 10    import java.io.File;
 11    import java.io.FileWriter;
 12    import java.io.IOException;
 13    import java.io.OutputStream;
 14    import java.io.StringWriter;
 15    import java.io.Writer;
 16    import java.util.Iterator;
 17   
 18    import javax.xml.namespace.QName;
 19    import javax.xml.stream.XMLEventFactory;
 20    import javax.xml.stream.XMLOutputFactory;
 21    import javax.xml.stream.XMLStreamException;
 22    import javax.xml.stream.events.Characters;
 23    import javax.xml.stream.events.DTD;
 24    import javax.xml.stream.events.EndDocument;
 25    import javax.xml.stream.events.EndElement;
 26    import javax.xml.stream.events.EntityReference;
 27    import javax.xml.stream.events.ProcessingInstruction;
 28    import javax.xml.stream.events.StartDocument;
 29    import javax.xml.stream.events.StartElement;
 30    import javax.xml.stream.util.XMLEventConsumer;
 31   
 32    import org.dom4j.Attribute;
 33    import org.dom4j.Branch;
 34    import org.dom4j.CDATA;
 35    import org.dom4j.Comment;
 36    import org.dom4j.Document;
 37    import org.dom4j.DocumentType;
 38    import org.dom4j.Element;
 39    import org.dom4j.Entity;
 40    import org.dom4j.Namespace;
 41    import org.dom4j.Node;
 42    import org.dom4j.Text;
 43   
 44    /**
 45    * Writes DOM4J {@link Node}s to a StAX event stream. In addition the
 46    * <code>createXXX</code> methods are provided to directly create STAX events
 47    * from DOM4J nodes.
 48    *
 49    * @author Christian Niles
 50    */
 51    public class STAXEventWriter {
 52    /** The event stream to which events are written. */
 53    private XMLEventConsumer consumer;
 54   
 55    /** The event factory used to construct events. */
 56    private XMLEventFactory factory = XMLEventFactory.newInstance();
 57   
 58    private XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
 59   
 60  0 public STAXEventWriter() {
 61    }
 62   
 63    /**
 64    * Constructs a <code>STAXEventWriter</code> that writes events to the
 65    * provided file.
 66    *
 67    * @param file
 68    * The file to which events will be written.
 69    *
 70    * @throws XMLStreamException
 71    * If an error occurs creating an event writer from the file.
 72    * @throws IOException
 73    * If an error occurs openin the file for writing.
 74    */
 75  0 public STAXEventWriter(File file) throws XMLStreamException, IOException {
 76  0 consumer = outputFactory.createXMLEventWriter(new FileWriter(file));
 77    }
 78   
 79    /**
 80    * Constructs a <code>STAXEventWriter</code> that writes events to the
 81    * provided character stream.
 82    *
 83    * @param writer
 84    * The character stream to which events will be written.
 85    *
 86    * @throws XMLStreamException
 87    * If an error occurs constructing an event writer from the
 88    * character stream.
 89    */
 90  1 public STAXEventWriter(Writer writer) throws XMLStreamException {
 91  1 consumer = outputFactory.createXMLEventWriter(writer);
 92    }
 93   
 94    /**
 95    * Constructs a <code>STAXEventWriter</code> that writes events to the
 96    * provided stream.
 97    *
 98    * @param stream
 99    * The output stream to which events will be written.
 100    *
 101    * @throws XMLStreamException
 102    * If an error occurs constructing an event writer from the
 103    * stream.
 104    */
 105  0 public STAXEventWriter(OutputStream stream) throws XMLStreamException {
 106  0 consumer = outputFactory.createXMLEventWriter(stream);
 107    }
 108   
 109    /**
 110    * Constructs a <code>STAXEventWriter</code> that writes events to the
 111    * provided event stream.
 112    *
 113    * @param consumer
 114    * The event stream to which events will be written.
 115    */
 116  0 public STAXEventWriter(XMLEventConsumer consumer) {
 117  0 this.consumer = consumer;
 118    }
 119   
 120    /**
 121    * Returns a reference to the underlying event consumer to which events are
 122    * written.
 123    *
 124    * @return The underlying event consumer to which events are written.
 125    */
 126  0 public XMLEventConsumer getConsumer() {
 127  0 return consumer;
 128    }
 129   
 130    /**
 131    * Sets the underlying event consumer to which events are written.
 132    *
 133    * @param consumer
 134    * The event consumer to which events should be written.
 135    */
 136  0 public void setConsumer(XMLEventConsumer consumer) {
 137  0 this.consumer = consumer;
 138    }
 139   
 140    /**
 141    * Returns a reference to the event factory used to construct STAX events.
 142    *
 143    * @return The event factory used to construct STAX events.
 144    */
 145  0 public XMLEventFactory getEventFactory() {
 146  0 return factory;
 147    }
 148   
 149    /**
 150    * Sets the event factory used to construct STAX events.
 151    *
 152    * @param eventFactory
 153    * The new event factory.
 154    */
 155  0 public void setEventFactory(XMLEventFactory eventFactory) {
 156  0 this.factory = eventFactory;
 157    }
 158   
 159    /**
 160    * Writes a DOM4J {@link Node}to the stream. This method is simply a
 161    * gateway to the overloaded methods such as {@link#writeElement(Element)}.
 162    *
 163    * @param n
 164    * The DOM4J {@link Node}to write to the stream.
 165    *
 166    * @throws XMLStreamException
 167    * If an error occurs writing to the stream.
 168    */
 169  24 public void writeNode(Node n) throws XMLStreamException {
 170  24 switch (n.getNodeType()) {
 171  8 case Node.ELEMENT_NODE:
 172  8 writeElement((Element) n);
 173   
 174  8 break;
 175   
 176  16 case Node.TEXT_NODE:
 177  16 writeText((Text) n);
 178   
 179  16 break;
 180   
 181  0 case Node.ATTRIBUTE_NODE:
 182  0 writeAttribute((Attribute) n);
 183   
 184  0 break;
 185   
 186  0 case Node.NAMESPACE_NODE:
 187  0 writeNamespace((Namespace) n);
 188   
 189  0 break;
 190   
 191  0 case Node.COMMENT_NODE:
 192  0 writeComment((Comment) n);
 193   
 194  0 break;
 195   
 196  0 case Node.CDATA_SECTION_NODE:
 197  0 writeCDATA((CDATA) n);
 198   
 199  0 break;
 200   
 201  0 case Node.PROCESSING_INSTRUCTION_NODE:
 202  0 writeProcessingInstruction((org.dom4j.ProcessingInstruction) n);
 203   
 204  0 break;
 205   
 206  0 case Node.ENTITY_REFERENCE_NODE:
 207  0 writeEntity((Entity) n);
 208   
 209  0 break;
 210   
 211  0 case Node.DOCUMENT_NODE:
 212  0 writeDocument((Document) n);
 213   
 214  0 break;
 215   
 216  0 case Node.DOCUMENT_TYPE_NODE:
 217  0 writeDocumentType((DocumentType) n);
 218   
 219  0 break;
 220   
 221  0 default:
 222  0 throw new XMLStreamException("Unsupported DOM4J Node: " + n);
 223    }
 224    }
 225   
 226    /**
 227    * Writes each child node within the provided {@link Branch}instance. This
 228    * method simply iterates through the {@link Branch}'s nodes and calls
 229    * {@link #writeNode(Node)}.
 230    *
 231    * @param branch
 232    * The node whose children will be written to the stream.
 233    *
 234    * @throws XMLStreamException
 235    * If an error occurs writing to the stream.
 236    */
 237  9 public void writeChildNodes(Branch branch) throws XMLStreamException {
 238  9 for (int i = 0, s = branch.nodeCount(); i < s; i++) {
 239  24 Node n = branch.node(i);
 240  24 writeNode(n);
 241    }
 242    }
 243   
 244    /**
 245    * Writes a DOM4J {@link Element}node and its children to the stream.
 246    *
 247    * @param elem
 248    * The {@link Element}node to write to the stream.
 249    *
 250    * @throws XMLStreamException
 251    * If an error occurs writing to the stream.
 252    */
 253  8 public void writeElement(Element elem) throws XMLStreamException {
 254  8 consumer.add(createStartElement(elem));
 255  8 writeChildNodes(elem);
 256  8 consumer.add(createEndElement(elem));
 257    }
 258   
 259    /**
 260    * Constructs a STAX {@link StartElement}event from a DOM4J {@link
 261    * Element}.
 262    *
 263    * @param elem
 264    * The {@link Element}from which to construct the event.
 265    *
 266    * @return The newly constructed {@link StartElement}event.
 267    */
 268  8 public StartElement createStartElement(Element elem) {
 269    // create name
 270  8 QName tagName = createQName(elem.getQName());
 271   
 272    // create attribute & namespace iterators
 273  8 Iterator attrIter = new AttributeIterator(elem.attributeIterator());
 274  8 Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
 275    .iterator());
 276   
 277    // create start event
 278  8 return factory.createStartElement(tagName, attrIter, nsIter);
 279    }
 280   
 281    /**
 282    * Constructs a STAX {@link EndElement}event from a DOM4J {@link Element}.
 283    *
 284    * @param elem
 285    * The {@link Element}from which to construct the event.
 286    *
 287    * @return The newly constructed {@link EndElement}event.
 288    */
 289  8 public EndElement createEndElement(Element elem) {
 290  8 QName tagName = createQName(elem.getQName());
 291  8 Iterator nsIter = new NamespaceIterator(elem.declaredNamespaces()
 292    .iterator());
 293   
 294  8 return factory.createEndElement(tagName, nsIter);
 295    }
 296   
 297    /**
 298    * Writes a DOM4J {@link Attribute}to the stream.
 299    *
 300    * @param attr
 301    * The {@link Attribute}to write to the stream.
 302    *
 303    * @throws XMLStreamException
 304    * If an error occurs writing to the stream.
 305    */
 306  0 public void writeAttribute(Attribute attr) throws XMLStreamException {
 307  0 consumer.add(createAttribute(attr));
 308    }
 309   
 310    /**
 311    * Constructs a STAX {@link javax.xml.stream.events.Attribute}event from a
 312    * DOM4J {@link Attribute}.
 313    *
 314    * @param attr
 315    * The {@link Attribute}from which to construct the event.
 316    *
 317    * @return The newly constructed {@link javax.xml.stream.events.Attribute}
 318    * event.
 319    */
 320  0 public javax.xml.stream.events.Attribute createAttribute(Attribute attr) {
 321  0 QName attrName = createQName(attr.getQName());
 322  0 String value = attr.getValue();
 323   
 324  0 return factory.createAttribute(attrName, value);
 325    }
 326   
 327    /**
 328    * Writes a DOM4J {@link Namespace}to the stream.
 329    *
 330    * @param ns
 331    * The {@link Namespace}to write to the stream.
 332    *
 333    * @throws XMLStreamException
 334    * If an error occurs writing to the stream.
 335    */
 336  0 public void writeNamespace(Namespace ns) throws XMLStreamException {
 337  0 consumer.add(createNamespace(ns));
 338    }
 339   
 340    /**
 341    * Constructs a STAX {@link javax.xml.stream.events.Namespace}event from a
 342    * DOM4J {@link Namespace}.
 343    *
 344    * @param ns
 345    * The {@link Namespace}from which to construct the event.
 346    *
 347    * @return The constructed {@link javax.xml.stream.events.Namespace}event.
 348    */
 349  0 public javax.xml.stream.events.Namespace createNamespace(Namespace ns) {
 350  0 String prefix = ns.getPrefix();
 351  0 String uri = ns.getURI();
 352   
 353  0 return factory.createNamespace(prefix, uri);
 354    }
 355   
 356    /**
 357    * Writes a DOM4J {@link Text}to the stream.
 358    *
 359    * @param text
 360    * The {@link Text}to write to the stream.
 361    *
 362    * @throws XMLStreamException
 363    * If an error occurs writing to the stream.
 364    */
 365  16 public void writeText(Text text) throws XMLStreamException {
 366  16 consumer.add(createCharacters(text));
 367    }
 368   
 369    /**
 370    * Constructs a STAX {@link Characters}event from a DOM4J {@link Text}.
 371    *
 372    * @param text
 373    * The {@link Text}from which to construct the event.
 374    *
 375    * @return The constructed {@link Characters}event.
 376    */
 377  16 public Characters createCharacters(Text text) {
 378  16 return factory.createCharacters(text.getText());
 379    }
 380   
 381    /**
 382    * Writes a DOM4J {@link CDATA}to the event stream.
 383    *
 384    * @param cdata
 385    * The {@link CDATA}to write to the stream.
 386    *
 387    * @throws XMLStreamException
 388    * If an error occurs writing to the stream.
 389    */
 390  0 public void writeCDATA(CDATA cdata) throws XMLStreamException {
 391  0 consumer.add(createCharacters(cdata));
 392    }
 393   
 394    /**
 395    * Constructs a STAX {@link Characters}event from a DOM4J {@link CDATA}.
 396    *
 397    * @param cdata
 398    * The {@link CDATA}from which to construct the event.
 399    *
 400    * @return The newly constructed {@link Characters}event.
 401    */
 402  0 public Characters createCharacters(CDATA cdata) {
 403  0 return factory.createCData(cdata.getText());
 404    }
 405   
 406    /**
 407    * Writes a DOM4J {@link Comment}to the stream.
 408    *
 409    * @param comment
 410    * The {@link Comment}to write to the stream.
 411    *
 412    * @throws XMLStreamException
 413    * If an error occurs writing to the stream.
 414    */
 415  0 public void writeComment(Comment comment) throws XMLStreamException {
 416  0 consumer.add(createComment(comment));
 417    }
 418   
 419    /**
 420    * Constructs a STAX {@link javax.xml.stream.events.Comment}event from a
 421    * DOM4J {@link Comment}.
 422    *
 423    * @param comment
 424    * The {@link Comment}from which to construct the event.
 425    *
 426    * @return The constructed {@link javax.xml.stream.events.Comment}event.
 427    */
 428  0 public javax.xml.stream.events.Comment createComment(Comment comment) {
 429  0 return factory.createComment(comment.getText());
 430    }
 431   
 432    /**
 433    * Writes a DOM4J {@link ProcessingInstruction}to the stream.
 434    *
 435    * @param pi
 436    * The {@link ProcessingInstruction}to write to the stream.
 437    *
 438    * @throws XMLStreamException
 439    * If an error occurs writing to the stream.
 440    */
 441  0 public void writeProcessingInstruction(org.dom4j.ProcessingInstruction pi)
 442    throws XMLStreamException {
 443  0 consumer.add(createProcessingInstruction(pi));
 444    }
 445   
 446    /**
 447    * Constructs a STAX {@link javax.xml.stream.events.ProcessingInstruction}
 448    * event from a DOM4J {@link ProcessingInstruction}.
 449    *
 450    * @param pi
 451    * The {@link ProcessingInstruction}from which to construct the
 452    * event.
 453    *
 454    * @return The constructed {@link
 455    * javax.xml.stream.events.ProcessingInstruction} event.
 456    */
 457  0 public ProcessingInstruction createProcessingInstruction(
 458    org.dom4j.ProcessingInstruction pi) {
 459  0 String target = pi.getTarget();
 460  0 String data = pi.getText();
 461   
 462  0 return factory.createProcessingInstruction(target, data);
 463    }
 464   
 465    /**
 466    * Writes a DOM4J {@link Entity}to the stream.
 467    *
 468    * @param entity
 469    * The {@link Entity}to write to the stream.
 470    *
 471    * @throws XMLStreamException
 472    * If an error occurs writing to the stream.
 473    */
 474  0 public void writeEntity(Entity entity) throws XMLStreamException {
 475  0 consumer.add(createEntityReference(entity));
 476    }
 477   
 478    /**
 479    * Constructs a STAX {@link EntityReference}event from a DOM4J {@link
 480    * Entity}.
 481    *
 482    * @param entity
 483    * The {@link Entity}from which to construct the event.
 484    *
 485    * @return The constructed {@link EntityReference}event.
 486    */
 487  0 private EntityReference createEntityReference(Entity entity) {
 488  0 return factory.createEntityReference(entity.getName(), null);
 489    }
 490   
 491    /**
 492    * Writes a DOM4J {@link DocumentType}to the stream.
 493    *
 494    * @param docType
 495    * The {@link DocumentType}to write to the stream.
 496    *
 497    * @throws XMLStreamException
 498    * If an error occurs writing to the stream.
 499    */
 500  0 public void writeDocumentType(DocumentType docType)
 501    throws XMLStreamException {
 502  0 consumer.add(createDTD(docType));
 503    }
 504   
 505    /**
 506    * Constructs a STAX {@link DTD}event from a DOM4J {@link DocumentType}.
 507    *
 508    * @param docType
 509    * The {@link DocumentType}from which to construct the event.
 510    *
 511    * @return The constructed {@link DTD}event.
 512    *
 513    * @throws RuntimeException
 514    * DOCUMENT ME!
 515    */
 516  0 public DTD createDTD(DocumentType docType) {
 517  0 StringWriter decl = new StringWriter();
 518   
 519  0 try {
 520  0 docType.write(decl);
 521    } catch (IOException e) {
 522  0 throw new RuntimeException("Error writing DTD", e);
 523    }
 524   
 525  0 return factory.createDTD(decl.toString());
 526    }
 527   
 528    /**
 529    * Writes a DOM4J {@link Document}node, and all its contents, to the
 530    * stream.
 531    *
 532    * @param doc
 533    * The {@link Document}to write to the stream.
 534    *
 535    * @throws XMLStreamException
 536    * If an error occurs writing to the stream.
 537    */
 538  1 public void writeDocument(Document doc) throws XMLStreamException {
 539  1 consumer.add(createStartDocument(doc));
 540   
 541  1 writeChildNodes(doc);
 542   
 543  1 consumer.add(createEndDocument(doc));
 544    }
 545   
 546    /**
 547    * Constructs a STAX {@link StartDocument}event from a DOM4J {@link
 548    * Document}.
 549    *
 550    * @param doc
 551    * The {@link Document}from which to construct the event.
 552    *
 553    * @return The constructed {@link StartDocument}event.
 554    */
 555  1 public StartDocument createStartDocument(Document doc) {
 556  1 String encoding = doc.getXMLEncoding();
 557   
 558  1 if (encoding != null) {
 559  1 return factory.createStartDocument(encoding);
 560    } else {
 561  0 return factory.createStartDocument();
 562    }
 563    }
 564   
 565    /**
 566    * Constructs a STAX {@link EndDocument}event from a DOM4J {@link
 567    * Document}.
 568    *
 569    * @param doc
 570    * The {@link Document}from which to construct the event.
 571    *
 572    * @return The constructed {@link EndDocument}event.
 573    */
 574  1 public EndDocument createEndDocument(Document doc) {
 575  1 return factory.createEndDocument();
 576    }
 577   
 578    /**
 579    * Constructs a STAX {@link QName}from a DOM4J {@link org.dom4j.QName}.
 580    *
 581    * @param qname
 582    * The {@link org.dom4j.QName}from which to construct the STAX
 583    * {@link QName}.
 584    *
 585    * @return The constructed {@link QName}.
 586    */
 587  16 public QName createQName(org.dom4j.QName qname) {
 588  16 return new QName(qname.getNamespaceURI(), qname.getName(), qname
 589    .getNamespacePrefix());
 590    }
 591   
 592    /**
 593    * Internal {@link Iterator}implementation used to pass DOM4J {@link
 594    * Attribute}s to the stream.
 595    */
 596    private class AttributeIterator implements Iterator {
 597    /** The underlying DOm4J attribute iterator. */
 598    private Iterator iter;
 599   
 600  8 public AttributeIterator(Iterator iter) {
 601  8 this.iter = iter;
 602    }
 603   
 604  8 public boolean hasNext() {
 605  8 return iter.hasNext();
 606    }
 607   
 608  0 public Object next() {
 609  0 Attribute attr = (Attribute) iter.next();
 610  0 QName attrName = createQName(attr.getQName());
 611  0 String value = attr.getValue();
 612   
 613  0 return factory.createAttribute(attrName, value);
 614    }
 615   
 616  0 public void remove() {
 617  0 throw new UnsupportedOperationException();
 618    }
 619    }
 620   
 621    /**
 622    * Internal {@link Iterator}implementation used to pass DOM4J {@link
 623    * Namespace}s to the stream.
 624    */
 625    private class NamespaceIterator implements Iterator {
 626    private Iterator iter;
 627   
 628  16 public NamespaceIterator(Iterator iter) {
 629  16 this.iter = iter;
 630    }
 631   
 632  16 public boolean hasNext() {
 633  16 return iter.hasNext();
 634    }
 635   
 636  0 public Object next() {
 637  0 Namespace ns = (Namespace) iter.next();
 638  0 String prefix = ns.getPrefix();
 639  0 String nsURI = ns.getURI();
 640   
 641  0 return factory.createNamespace(prefix, nsURI);
 642    }
 643   
 644  0 public void remove() {
 645  0 throw new UnsupportedOperationException();
 646    }
 647    }
 648    }
 649   
 650    /*
 651    * Redistribution and use of this software and associated documentation
 652    * ("Software"), with or without modification, are permitted provided that the
 653    * following conditions are met:
 654    *
 655    * 1. Redistributions of source code must retain copyright statements and
 656    * notices. Redistributions must also contain a copy of this document.
 657    *
 658    * 2. Redistributions in binary form must reproduce the above copyright notice,
 659    * this list of conditions and the following disclaimer in the documentation
 660    * and/or other materials provided with the distribution.
 661    *
 662    * 3. The name "DOM4J" must not be used to endorse or promote products derived
 663    * from this Software without prior written permission of MetaStuff, Ltd. For
 664    * written permission, please contact dom4j-info@metastuff.com.
 665    *
 666    * 4. Products derived from this Software may not be called "DOM4J" nor may
 667    * "DOM4J" appear in their names without prior written permission of MetaStuff,
 668    * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
 669    *
 670    * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
 671    *
 672    * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
 673    * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 674    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 675    * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
 676    * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 677    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 678    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 679    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 680    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 681    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 682    * POSSIBILITY OF SUCH DAMAGE.
 683    *
 684    * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 685    */
 
CloverReport generated by Clover Code Coverage v1.3.5
ma mei 16 2005 14:23:02 GMT+01:00.		   Open Source License registered to the dom4j Project. This license of Clover is provided to support the development of dom4j only.