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: 1.042   Methods: 58
NCLOC: 382   Classes: 2
 
 Source file Conditionals Statements Methods TOTAL
SAXReader.java 51,9% 62,6% 58,6% 59,7%
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.FileInputStream;
 12    import java.io.FileNotFoundException;
 13    import java.io.InputStream;
 14    import java.io.Reader;
 15    import java.io.Serializable;
 16    import java.net.URL;
 17   
 18    import org.dom4j.Document;
 19    import org.dom4j.DocumentException;
 20    import org.dom4j.DocumentFactory;
 21    import org.dom4j.ElementHandler;
 22   
 23    import org.xml.sax.EntityResolver;
 24    import org.xml.sax.ErrorHandler;
 25    import org.xml.sax.InputSource;
 26    import org.xml.sax.SAXException;
 27    import org.xml.sax.SAXParseException;
 28    import org.xml.sax.XMLFilter;
 29    import org.xml.sax.XMLReader;
 30    import org.xml.sax.helpers.DefaultHandler;
 31    import org.xml.sax.helpers.XMLReaderFactory;
 32   
 33    /**
 34    * <p>
 35    * <code>SAXReader</code> creates a DOM4J tree from SAX parsing events.
 36    * </p>
 37    *
 38    * <p>
 39    * The actual SAX parser that is used by this class is configurable so you can
 40    * use your favourite SAX parser if you wish. DOM4J comes configured with its
 41    * own SAX parser so you do not need to worry about configuring the SAX parser.
 42    * </p>
 43    *
 44    * <p>
 45    * To explicitly configure the SAX parser that is used via Java code you can use
 46    * a constructor or use the {@link #setXMLReader(XMLReader)}or {@link
 47    * #setXMLReaderClassName(String)} methods.
 48    * </p>
 49    *
 50    * <p>
 51    * If the parser is not specified explicitly then the standard SAX policy of
 52    * using the <code>org.xml.sax.driver</code> system property is used to
 53    * determine the implementation class of {@link XMLReader}.
 54    * </p>
 55    *
 56    * <p>
 57    * If the <code>org.xml.sax.driver</code> system property is not defined then
 58    * JAXP is used via reflection (so that DOM4J is not explicitly dependent on the
 59    * JAXP classes) to load the JAXP configured SAXParser. If there is any error
 60    * creating a JAXP SAXParser an informational message is output and then the
 61    * default (Aelfred) SAX parser is used instead.
 62    * </p>
 63    *
 64    * <p>
 65    * If you are trying to use JAXP to explicitly set your SAX parser and are
 66    * experiencing problems, you can turn on verbose error reporting by defining
 67    * the system property <code>org.dom4j.verbose</code> to be "true" which will
 68    * output a more detailed description of why JAXP could not find a SAX parser
 69    * </p>
 70    *
 71    * <p>
 72    * For more information on JAXP please go to <a
 73    * href="http://java.sun.com/xml/">Sun's Java &amp; XML site </a>
 74    * </p>
 75    *
 76    * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>
 77    * @version $Revision: 1.58 $
 78    */
 79    public class SAXReader {
 80    private static final String SAX_STRING_INTERNING =
 81    "http://xml.org/sax/features/string-interning";
 82    private static final String SAX_NAMESPACE_PREFIXES =
 83    "http://xml.org/sax/features/namespace-prefixes";
 84    private static final String SAX_NAMESPACES =
 85    "http://xml.org/sax/features/namespaces";
 86    private static final String SAX_DECL_HANDLER =
 87    "http://xml.org/sax/properties/declaration-handler";
 88    private static final String SAX_LEXICAL_HANDLER =
 89    "http://xml.org/sax/properties/lexical-handler";
 90    private static final String SAX_LEXICALHANDLER =
 91    "http://xml.org/sax/handlers/LexicalHandler";
 92   
 93    /** <code>DocumentFactory</code> used to create new document objects */
 94    private DocumentFactory factory;
 95   
 96    /** <code>XMLReader</code> used to parse the SAX events */
 97    private XMLReader xmlReader;
 98   
 99    /** Whether validation should occur */
 100    private boolean validating;
 101   
 102    /** DispatchHandler to call when each <code>Element</code> is encountered */
 103    private DispatchHandler dispatchHandler;
 104   
 105    /** ErrorHandler class to use */
 106    private ErrorHandler errorHandler;
 107   
 108    /** The entity resolver */
 109    private EntityResolver entityResolver;
 110   
 111    /** Should element & attribute names and namespace URIs be interned? */
 112    private boolean stringInternEnabled = true;
 113   
 114    /** Should internal DTD declarations be expanded into a List in the DTD */
 115    private boolean includeInternalDTDDeclarations = false;
 116   
 117    /** Should external DTD declarations be expanded into a List in the DTD */
 118    private boolean includeExternalDTDDeclarations = false;
 119   
 120    /** Whether adjacent text nodes should be merged */
 121    private boolean mergeAdjacentText = false;
 122   
 123    /** Holds value of property stripWhitespaceText. */
 124    private boolean stripWhitespaceText = false;
 125   
 126    /** Should we ignore comments */
 127    private boolean ignoreComments = false;
 128   
 129    /** Encoding of InputSource - null means system default encoding */
 130    private String encoding = null;
 131   
 132    // private boolean includeExternalGeneralEntities = false;
 133    // private boolean includeExternalParameterEntities = false;
 134   
 135    /** The SAX filter used to filter SAX events */
 136    private XMLFilter xmlFilter;
 137   
 138  5741 public SAXReader() {
 139    }
 140   
 141  1 public SAXReader(boolean validating) {
 142  1 this.validating = validating;
 143    }
 144   
 145  55 public SAXReader(DocumentFactory factory) {
 146  55 this.factory = factory;
 147    }
 148   
 149  0 public SAXReader(DocumentFactory factory, boolean validating) {
 150  0 this.factory = factory;
 151  0 this.validating = validating;
 152    }
 153   
 154  0 public SAXReader(XMLReader xmlReader) {
 155  0 this.xmlReader = xmlReader;
 156    }
 157   
 158  0 public SAXReader(XMLReader xmlReader, boolean validating) {
 159  0 this.xmlReader = xmlReader;
 160  0 this.validating = validating;
 161    }
 162   
 163  1 public SAXReader(String xmlReaderClassName) throws SAXException {
 164  1 if (xmlReaderClassName != null) {
 165  1 this.xmlReader = XMLReaderFactory
 166    .createXMLReader(xmlReaderClassName);
 167    }
 168    }
 169   
 170  0 public SAXReader(String xmlReaderClassName, boolean validating)
 171    throws SAXException {
 172  0 if (xmlReaderClassName != null) {
 173  0 this.xmlReader = XMLReaderFactory
 174    .createXMLReader(xmlReaderClassName);
 175    }
 176   
 177  0 this.validating = validating;
 178    }
 179   
 180    /**
 181    * Allows a SAX property to be set on the underlying SAX parser. This can be
 182    * useful to set parser-specific properties such as the location of schema
 183    * or DTD resources. Though use this method with caution as it has the
 184    * possibility of breaking the standard behaviour. An alternative to calling
 185    * this method is to correctly configure an XMLReader object instance and
 186    * call the {@link #setXMLReader(XMLReader)}method
 187    *
 188    * @param name
 189    * is the SAX property name
 190    * @param value
 191    * is the value of the SAX property
 192    *
 193    * @throws SAXException
 194    * if the XMLReader could not be created or the property could
 195    * not be changed.
 196    */
 197  0 public void setProperty(String name, Object value) throws SAXException {
 198  0 getXMLReader().setProperty(name, value);
 199    }
 200   
 201    /**
 202    * Sets a SAX feature on the underlying SAX parser. This can be useful to
 203    * set parser-specific features. Though use this method with caution as it
 204    * has the possibility of breaking the standard behaviour. An alternative to
 205    * calling this method is to correctly configure an XMLReader object
 206    * instance and call the {@link #setXMLReader(XMLReader)}method
 207    *
 208    * @param name
 209    * is the SAX feature name
 210    * @param value
 211    * is the value of the SAX feature
 212    *
 213    * @throws SAXException
 214    * if the XMLReader could not be created or the feature could
 215    * not be changed.
 216    */
 217  0 public void setFeature(String name, boolean value) throws SAXException {
 218  0 getXMLReader().setFeature(name, value);
 219    }
 220   
 221    /**
 222    * <p>
 223    * Reads a Document from the given <code>File</code>
 224    * </p>
 225    *
 226    * @param file
 227    * is the <code>File</code> to read from.
 228    *
 229    * @return the newly created Document instance
 230    *
 231    * @throws DocumentException
 232    * if an error occurs during parsing.
 233    */
 234  204 public Document read(File file) throws DocumentException {
 235  204 try {
 236    /*
 237    * We cannot convert the file to an URL because if the filename
 238    * contains '#' characters, there will be problems with the URL in
 239    * the InputSource (because a URL like
 240    * http://myhost.com/index#anchor is treated the same as
 241    * http://myhost.com/index) Thanks to Christian Oetterli
 242    */
 243  204 InputSource source = new InputSource(new FileInputStream(file));
 244  204 if (this.encoding != null) {
 245  0 source.setEncoding(this.encoding);
 246    }
 247  204 String path = file.getAbsolutePath();
 248   
 249  204 if (path != null) {
 250    // Code taken from Ant FileUtils
 251  204 StringBuffer sb = new StringBuffer("file://");
 252   
 253    // add an extra slash for filesystems with drive-specifiers
 254  204 if (!path.startsWith(File.separator)) {
 255  204 sb.append("/");
 256    }
 257   
 258  204 path = path.replace('\\', '/');
 259  204 sb.append(path);
 260   
 261  204 source.setSystemId(sb.toString());
 262    }
 263   
 264  204 return read(source);
 265    } catch (FileNotFoundException e) {
 266  0 throw new DocumentException(e.getMessage(), e);
 267    }
 268    }
 269   
 270    /**
 271    * <p>
 272    * Reads a Document from the given <code>URL</code> using SAX
 273    * </p>
 274    *
 275    * @param url
 276    * <code>URL</code> to read from.
 277    *
 278    * @return the newly created Document instance
 279    *
 280    * @throws DocumentException
 281    * if an error occurs during parsing.
 282    */
 283  0 public Document read(URL url) throws DocumentException {
 284  0 String systemID = url.toExternalForm();
 285   
 286  0 InputSource source = new InputSource(systemID);
 287  0 if (this.encoding != null) {
 288  0 source.setEncoding(this.encoding);
 289    }
 290   
 291  0 return read(source);
 292    }
 293   
 294    /**
 295    * <p>
 296    * Reads a Document from the given URL or filename using SAX.
 297    * </p>
 298    *
 299    * <p>
 300    * If the systemId contains a <code>':'</code> character then it is
 301    * assumed to be a URL otherwise its assumed to be a file name. If you want
 302    * finer grained control over this mechansim then please explicitly pass in
 303    * either a {@link URL}or a {@link File}instance instead of a {@link
 304    * String} to denote the source of the document.
 305    * </p>
 306    *
 307    * @param systemId
 308    * is a URL for a document or a file name.
 309    *
 310    * @return the newly created Document instance
 311    *
 312    * @throws DocumentException
 313    * if an error occurs during parsing.
 314    */
 315  1 public Document read(String systemId) throws DocumentException {
 316  1 InputSource source = new InputSource(systemId);
 317  1 if (this.encoding != null) {
 318  0 source.setEncoding(this.encoding);
 319    }
 320   
 321  1 return read(source);
 322    }
 323   
 324    /**
 325    * <p>
 326    * Reads a Document from the given stream using SAX
 327    * </p>
 328    *
 329    * @param in
 330    * <code>InputStream</code> to read from.
 331    *
 332    * @return the newly created Document instance
 333    *
 334    * @throws DocumentException
 335    * if an error occurs during parsing.
 336    */
 337  1 public Document read(InputStream in) throws DocumentException {
 338  1 InputSource source = new InputSource(in);
 339  1 if (this.encoding != null) {
 340  0 source.setEncoding(this.encoding);
 341    }
 342   
 343  1 return read(source);
 344    }
 345   
 346    /**
 347    * <p>
 348    * Reads a Document from the given <code>Reader</code> using SAX
 349    * </p>
 350    *
 351    * @param reader
 352    * is the reader for the input
 353    *
 354    * @return the newly created Document instance
 355    *
 356    * @throws DocumentException
 357    * if an error occurs during parsing.
 358    */
 359  31 public Document read(Reader reader) throws DocumentException {
 360  31 InputSource source = new InputSource(reader);
 361  31 if (this.encoding != null) {
 362  1 source.setEncoding(this.encoding);
 363    }
 364   
 365  31 return read(source);
 366    }
 367   
 368    /**
 369    * <p>
 370    * Reads a Document from the given stream using SAX
 371    * </p>
 372    *
 373    * @param in
 374    * <code>InputStream</code> to read from.
 375    * @param systemId
 376    * is the URI for the input
 377    *
 378    * @return the newly created Document instance
 379    *
 380    * @throws DocumentException
 381    * if an error occurs during parsing.
 382    */
 383  0 public Document read(InputStream in, String systemId)
 384    throws DocumentException {
 385  0 InputSource source = new InputSource(in);
 386  0 source.setSystemId(systemId);
 387  0 if (this.encoding != null) {
 388  0 source.setEncoding(this.encoding);
 389    }
 390   
 391  0 return read(source);
 392    }
 393   
 394    /**
 395    * <p>
 396    * Reads a Document from the given <code>Reader</code> using SAX
 397    * </p>
 398    *
 399    * @param reader
 400    * is the reader for the input
 401    * @param systemId
 402    * is the URI for the input
 403    *
 404    * @return the newly created Document instance
 405    *
 406    * @throws DocumentException
 407    * if an error occurs during parsing.
 408    */
 409  0 public Document read(Reader reader, String systemId)
 410    throws DocumentException {
 411  0 InputSource source = new InputSource(reader);
 412  0 source.setSystemId(systemId);
 413  0 if (this.encoding != null) {
 414  0 source.setEncoding(this.encoding);
 415    }
 416   
 417  0 return read(source);
 418    }
 419   
 420    /**
 421    * <p>
 422    * Reads a Document from the given <code>InputSource</code> using SAX
 423    * </p>
 424    *
 425    * @param in
 426    * <code>InputSource</code> to read from.
 427    *
 428    * @return the newly created Document instance
 429    *
 430    * @throws DocumentException
 431    * if an error occurs during parsing.
 432    */
 433  5792 public Document read(InputSource in) throws DocumentException {
 434  5792 try {
 435  5792 XMLReader reader = getXMLReader();
 436   
 437  5792 reader = installXMLFilter(reader);
 438   
 439  5792 EntityResolver thatEntityResolver = this.entityResolver;
 440   
 441  5792 if (thatEntityResolver == null) {
 442  5762 thatEntityResolver = createDefaultEntityResolver(in
 443    .getSystemId());
 444  5762 this.entityResolver = thatEntityResolver;
 445    }
 446   
 447  5792 reader.setEntityResolver(thatEntityResolver);
 448   
 449  5792 SAXContentHandler contentHandler = createContentHandler(reader);
 450  5792 contentHandler.setEntityResolver(thatEntityResolver);
 451  5792 contentHandler.setInputSource(in);
 452   
 453  5792 boolean internal = isIncludeInternalDTDDeclarations();
 454  5792 boolean external = isIncludeExternalDTDDeclarations();
 455   
 456  5792 contentHandler.setIncludeInternalDTDDeclarations(internal);
 457  5792 contentHandler.setIncludeExternalDTDDeclarations(external);
 458  5792 contentHandler.setMergeAdjacentText(isMergeAdjacentText());
 459  5792 contentHandler.setStripWhitespaceText(isStripWhitespaceText());
 460  5792 contentHandler.setIgnoreComments(isIgnoreComments());
 461  5792 reader.setContentHandler(contentHandler);
 462   
 463  5792 configureReader(reader, contentHandler);
 464   
 465  5792 reader.parse(in);
 466   
 467  5791 return contentHandler.getDocument();
 468    } catch (Exception e) {
 469  1 if (e instanceof SAXParseException) {
 470    // e.printStackTrace();
 471  0 SAXParseException parseException = (SAXParseException) e;
 472  0 String systemId = parseException.getSystemId();
 473   
 474  0 if (systemId == null) {
 475  0 systemId = "";
 476    }
 477   
 478  0 String message = "Error on line "
 479    + parseException.getLineNumber() + " of document "
 480    + systemId + " : " + parseException.getMessage();
 481   
 482  0 throw new DocumentException(message, e);
 483    } else {
 484  1 throw new DocumentException(e.getMessage(), e);
 485    }
 486    }
 487    }
 488   
 489    // Properties
 490    // -------------------------------------------------------------------------
 491   
 492    /**
 493    * DOCUMENT ME!
 494    *
 495    * @return the validation mode, true if validating will be done otherwise
 496    * false.
 497    */
 498  11556 public boolean isValidating() {
 499  11556 return validating;
 500    }
 501   
 502    /**
 503    * Sets the validation mode.
 504    *
 505    * @param validation
 506    * indicates whether or not validation should occur.
 507    */
 508  0 public void setValidation(boolean validation) {
 509  0 this.validating = validation;
 510    }
 511   
 512    /**
 513    * DOCUMENT ME!
 514    *
 515    * @return whether internal DTD declarations should be expanded into the
 516    * DocumentType object or not.
 517    */
 518  5792 public boolean isIncludeInternalDTDDeclarations() {
 519  5792 return includeInternalDTDDeclarations;
 520    }
 521   
 522    /**
 523    * Sets whether internal DTD declarations should be expanded into the
 524    * DocumentType object or not.
 525    *
 526    * @param include
 527    * whether or not DTD declarations should be expanded and
 528    * included into the DocumentType object.
 529    */
 530  5 public void setIncludeInternalDTDDeclarations(boolean include) {
 531  5 this.includeInternalDTDDeclarations = include;
 532    }
 533   
 534    /**
 535    * DOCUMENT ME!
 536    *
 537    * @return whether external DTD declarations should be expanded into the
 538    * DocumentType object or not.
 539    */
 540  5792 public boolean isIncludeExternalDTDDeclarations() {
 541  5792 return includeExternalDTDDeclarations;
 542    }
 543   
 544    /**
 545    * Sets whether DTD external declarations should be expanded into the
 546    * DocumentType object or not.
 547    *
 548    * @param include
 549    * whether or not DTD declarations should be expanded and
 550    * included into the DocumentType object.
 551    */
 552  4 public void setIncludeExternalDTDDeclarations(boolean include) {
 553  4 this.includeExternalDTDDeclarations = include;
 554    }
 555   
 556    /**
 557    * Sets whether String interning is enabled or disabled for element &
 558    * attribute names and namespace URIs. This proprety is enabled by default.
 559    *
 560    * @return DOCUMENT ME!
 561    */
 562  5792 public boolean isStringInternEnabled() {
 563  5792 return stringInternEnabled;
 564    }
 565   
 566    /**
 567    * Sets whether String interning is enabled or disabled for element &
 568    * attribute names and namespace URIs
 569    *
 570    * @param stringInternEnabled
 571    * DOCUMENT ME!
 572    */
 573  0 public void setStringInternEnabled(boolean stringInternEnabled) {
 574  0 this.stringInternEnabled = stringInternEnabled;
 575    }
 576   
 577    /**
 578    * Returns whether adjacent text nodes should be merged together.
 579    *
 580    * @return Value of property mergeAdjacentText.
 581    */
 582  5792 public boolean isMergeAdjacentText() {
 583  5792 return mergeAdjacentText;
 584    }
 585   
 586    /**
 587    * Sets whether or not adjacent text nodes should be merged together when
 588    * parsing.
 589    *
 590    * @param mergeAdjacentText
 591    * New value of property mergeAdjacentText.
 592    */
 593  7 public void setMergeAdjacentText(boolean mergeAdjacentText) {
 594  7 this.mergeAdjacentText = mergeAdjacentText;
 595    }
 596   
 597    /**
 598    * Sets whether whitespace between element start and end tags should be
 599    * ignored
 600    *
 601    * @return Value of property stripWhitespaceText.
 602    */
 603  5792 public boolean isStripWhitespaceText() {
 604  5792 return stripWhitespaceText;
 605    }
 606   
 607    /**
 608    * Sets whether whitespace between element start and end tags should be
 609    * ignored.
 610    *
 611    * @param stripWhitespaceText
 612    * New value of property stripWhitespaceText.
 613    */
 614  0 public void setStripWhitespaceText(boolean stripWhitespaceText) {
 615  0 this.stripWhitespaceText = stripWhitespaceText;
 616    }
 617   
 618    /**
 619    * Returns whether we should ignore comments or not.
 620    *
 621    * @return boolean
 622    */
 623  5792 public boolean isIgnoreComments() {
 624  5792 return ignoreComments;
 625    }
 626   
 627    /**
 628    * Sets whether we should ignore comments or not.
 629    *
 630    * @param ignoreComments
 631    * whether we should ignore comments or not.
 632    */
 633  0 public void setIgnoreComments(boolean ignoreComments) {
 634  0 this.ignoreComments = ignoreComments;
 635    }
 636   
 637    /**
 638    * DOCUMENT ME!
 639    *
 640    * @return the <code>DocumentFactory</code> used to create document
 641    * objects
 642    */
 643  5792 public DocumentFactory getDocumentFactory() {
 644  5792 if (factory == null) {
 645  5702 factory = DocumentFactory.getInstance();
 646    }
 647   
 648  5792 return factory;
 649    }
 650   
 651    /**
 652    * <p>
 653    * This sets the <code>DocumentFactory</code> used to create new
 654    * documents. This method allows the building of custom DOM4J tree objects
 655    * to be implemented easily using a custom derivation of
 656    * {@link DocumentFactory}
 657    * </p>
 658    *
 659    * @param documentFactory
 660    * <code>DocumentFactory</code> used to create DOM4J objects
 661    */
 662  8 public void setDocumentFactory(DocumentFactory documentFactory) {
 663  8 this.factory = documentFactory;
 664    }
 665   
 666    /**
 667    * DOCUMENT ME!
 668    *
 669    * @return the <code>ErrorHandler</code> used by SAX
 670    */
 671  0 public ErrorHandler getErrorHandler() {
 672  0 return errorHandler;
 673    }
 674   
 675    /**
 676    * Sets the <code>ErrorHandler</code> used by the SAX
 677    * <code>XMLReader</code>.
 678    *
 679    * @param errorHandler
 680    * is the <code>ErrorHandler</code> used by SAX
 681    */
 682  0 public void setErrorHandler(ErrorHandler errorHandler) {
 683  0 this.errorHandler = errorHandler;
 684    }
 685   
 686    /**
 687    * Returns the current entity resolver used to resolve entities
 688    *
 689    * @return DOCUMENT ME!
 690    */
 691  0 public EntityResolver getEntityResolver() {
 692  0 return entityResolver;
 693    }
 694   
 695    /**
 696    * Sets the entity resolver used to resolve entities.
 697    *
 698    * @param entityResolver
 699    * DOCUMENT ME!
 700    */
 701  3 public void setEntityResolver(EntityResolver entityResolver) {
 702  3 this.entityResolver = entityResolver;
 703    }
 704   
 705    /**
 706    * DOCUMENT ME!
 707    *
 708    * @return the <code>XMLReader</code> used to parse SAX events
 709    *
 710    * @throws SAXException
 711    * DOCUMENT ME!
 712    */
 713  5792 public XMLReader getXMLReader() throws SAXException {
 714  5792 if (xmlReader == null) {
 715  5764 xmlReader = createXMLReader();
 716    }
 717   
 718  5792 return xmlReader;
 719    }
 720   
 721    /**
 722    * Sets the <code>XMLReader</code> used to parse SAX events
 723    *
 724    * @param reader
 725    * is the <code>XMLReader</code> to parse SAX events
 726    */
 727  0 public void setXMLReader(XMLReader reader) {
 728  0 this.xmlReader = reader;
 729    }
 730   
 731    /**
 732    * Returns encoding used for InputSource (null means system default
 733    * encoding)
 734    *
 735    * @return encoding used for InputSource
 736    *
 737    */
 738  0 public String getEncoding() {
 739  0 return encoding;
 740    }
 741   
 742    /**
 743    * Sets encoding used for InputSource (null means system default encoding)
 744    *
 745    * @param encoding
 746    * is encoding used for InputSource
 747    */
 748  1 public void setEncoding(String encoding) {
 749  1 this.encoding = encoding;
 750    }
 751   
 752    /**
 753    * Sets the class name of the <code>XMLReader</code> to be used to parse
 754    * SAX events.
 755    *
 756    * @param xmlReaderClassName
 757    * is the class name of the <code>XMLReader</code> to parse SAX
 758    * events
 759    *
 760    * @throws SAXException
 761    * DOCUMENT ME!
 762    */
 763  0 public void setXMLReaderClassName(String xmlReaderClassName)
 764    throws SAXException {
 765  0 setXMLReader(XMLReaderFactory.createXMLReader(xmlReaderClassName));
 766    }
 767   
 768    /**
 769    * Adds the <code>ElementHandler</code> to be called when the specified
 770    * path is encounted.
 771    *
 772    * @param path
 773    * is the path to be handled
 774    * @param handler
 775    * is the <code>ElementHandler</code> to be called by the event
 776    * based processor.
 777    */
 778  21 public void addHandler(String path, ElementHandler handler) {
 779  21 getDispatchHandler().addHandler(path, handler);
 780    }
 781   
 782    /**
 783    * Removes the <code>ElementHandler</code> from the event based processor,
 784    * for the specified path.
 785    *
 786    * @param path
 787    * is the path to remove the <code>ElementHandler</code> for.
 788    */
 789  0 public void removeHandler(String path) {
 790  0 getDispatchHandler().removeHandler(path);
 791    }
 792   
 793    /**
 794    * When multiple <code>ElementHandler</code> instances have been
 795    * registered, this will set a default <code>ElementHandler</code> to be
 796    * called for any path which does <b>NOT </b> have a handler registered.
 797    *
 798    * @param handler
 799    * is the <code>ElementHandler</code> to be called by the event
 800    * based processor.
 801    */
 802  0 public void setDefaultHandler(ElementHandler handler) {
 803  0 getDispatchHandler().setDefaultHandler(handler);
 804    }
 805   
 806    /**
 807    * This method clears out all the existing handlers and default handler
 808    * setting things back as if no handler existed. Useful when reusing an
 809    * object instance.
 810    */
 811  0 public void resetHandlers() {
 812  0 getDispatchHandler().resetHandlers();
 813    }
 814   
 815    /**
 816    * Returns the SAX filter being used to filter SAX events.
 817    *
 818    * @return the SAX filter being used or null if no SAX filter is installed
 819    */
 820  5792 public XMLFilter getXMLFilter() {
 821  5792 return xmlFilter;
 822    }
 823   
 824    /**
 825    * Sets the SAX filter to be used when filtering SAX events
 826    *
 827    * @param filter
 828    * is the SAX filter to use or null to disable filtering
 829    */
 830  0 public void setXMLFilter(XMLFilter filter) {
 831  0 this.xmlFilter = filter;
 832    }
 833   
 834    // Implementation methods
 835    // -------------------------------------------------------------------------
 836   
 837    /**
 838    * Installs any XMLFilter objects required to allow the SAX event stream to
 839    * be filtered and preprocessed before it gets to dom4j.
 840    *
 841    * @param reader
 842    * DOCUMENT ME!
 843    *
 844    * @return the new XMLFilter if applicable or the original XMLReader if no
 845    * filter is being used.
 846    */
 847  5792 protected XMLReader installXMLFilter(XMLReader reader) {
 848  5792 XMLFilter filter = getXMLFilter();
 849   
 850  5792 if (filter != null) {
 851    // find the root XMLFilter
 852  0 XMLFilter root = filter;
 853   
 854  0 while (true) {
 855  0 XMLReader parent = root.getParent();
 856   
 857  0 if (parent instanceof XMLFilter) {
 858  0 root = (XMLFilter) parent;
 859    } else {
 860  0 break;
 861    }
 862    }
 863   
 864  0 root.setParent(reader);
 865   
 866  0 return filter;
 867    }
 868   
 869  5792 return reader;
 870    }
 871   
 872  21 protected DispatchHandler getDispatchHandler() {
 873  21 if (dispatchHandler == null) {
 874  21 dispatchHandler = new DispatchHandler();
 875    }
 876   
 877  21 return dispatchHandler;
 878    }
 879   
 880  0 protected void setDispatchHandler(DispatchHandler dispatchHandler) {
 881  0 this.dispatchHandler = dispatchHandler;
 882    }
 883   
 884    /**
 885    * Factory Method to allow alternate methods of creating and configuring
 886    * XMLReader objects
 887    *
 888    * @return DOCUMENT ME!
 889    *
 890    * @throws SAXException
 891    * DOCUMENT ME!
 892    */
 893  5764 protected XMLReader createXMLReader() throws SAXException {
 894  5764 return SAXHelper.createXMLReader(isValidating());
 895    }
 896   
 897    /**
 898    * Configures the XMLReader before use
 899    *
 900    * @param reader
 901    * DOCUMENT ME!
 902    * @param handler
 903    * DOCUMENT ME!
 904    *
 905    * @throws DocumentException
 906    * DOCUMENT ME!
 907    */
 908  5792 protected void configureReader(XMLReader reader, DefaultHandler handler)
 909    throws DocumentException {
 910    // configure lexical handling
 911  5792 SAXHelper.setParserProperty(reader, SAX_LEXICALHANDLER, handler);
 912   
 913    // try alternate property just in case
 914  5792 SAXHelper.setParserProperty(reader, SAX_LEXICAL_HANDLER, handler);
 915   
 916    // register the DeclHandler
 917  5792 if (includeInternalDTDDeclarations || includeExternalDTDDeclarations) {
 918  6 SAXHelper.setParserProperty(reader, SAX_DECL_HANDLER, handler);
 919    }
 920   
 921    // configure namespace support
 922  5792 SAXHelper.setParserFeature(reader, SAX_NAMESPACES, true);
 923   
 924  5792 SAXHelper.setParserFeature(reader, SAX_NAMESPACE_PREFIXES, false);
 925   
 926    // string interning
 927  5792 SAXHelper.setParserFeature(reader, SAX_STRING_INTERNING,
 928    isStringInternEnabled());
 929   
 930    // external entites
 931    /*
 932    * SAXHelper.setParserFeature( reader,
 933    * "http://xml.org/sax/properties/external-general-entities",
 934    * includeExternalGeneralEntities ); SAXHelper.setParserFeature( reader,
 935    * "http://xml.org/sax/properties/external-parameter-entities",
 936    * includeExternalParameterEntities );
 937    */
 938    // use Locator2 if possible
 939  5792 SAXHelper.setParserFeature(reader,
 940    "http://xml.org/sax/features/use-locator2", true);
 941   
 942  5792 try {
 943    // configure validation support
 944  5792 reader.setFeature("http://xml.org/sax/features/validation",
 945    isValidating());
 946   
 947  5792 if (errorHandler != null) {
 948  0 reader.setErrorHandler(errorHandler);
 949    } else {
 950  5792 reader.setErrorHandler(handler);
 951    }
 952    } catch (Exception e) {
 953  0 if (isValidating()) {
 954  0 throw new DocumentException("Validation not supported for"
 955    + " XMLReader: " + reader, e);
 956    }
 957    }
 958    }
 959   
 960    /**
 961    * Factory Method to allow user derived SAXContentHandler objects to be used
 962    *
 963    * @param reader
 964    * DOCUMENT ME!
 965    *
 966    * @return DOCUMENT ME!
 967    */
 968  5792 protected SAXContentHandler createContentHandler(XMLReader reader) {
 969  5792 return new SAXContentHandler(getDocumentFactory(), dispatchHandler);
 970    }
 971   
 972  5762 protected EntityResolver createDefaultEntityResolver(String systemId) {
 973  5762 String prefix = null;
 974   
 975  5762 if ((systemId != null) && (systemId.length() > 0)) {
 976  179 int idx = systemId.lastIndexOf('/');
 977   
 978  179 if (idx > 0) {
 979  178 prefix = systemId.substring(0, idx + 1);
 980    }
 981    }
 982   
 983  5762 return new SAXEntityResolver(prefix);
 984    }
 985   
 986    protected static class SAXEntityResolver implements EntityResolver,
 987    Serializable {
 988    protected String uriPrefix;
 989   
 990  5762 public SAXEntityResolver(String uriPrefix) {
 991  5762 this.uriPrefix = uriPrefix;
 992    }
 993   
 994  5 public InputSource resolveEntity(String publicId, String systemId) {
 995    // try create a relative URI reader...
 996  5 if ((systemId != null) && (systemId.length() > 0)) {
 997  5 if ((uriPrefix != null) && (systemId.indexOf(':') <= 0)) {
 998  2 systemId = uriPrefix + systemId;
 999    }
 1000    }
 1001   
 1002  5 return new InputSource(systemId);
 1003    }
 1004    }
 1005    }
 1006   
 1007    /*
 1008    * Redistribution and use of this software and associated documentation
 1009    * ("Software"), with or without modification, are permitted provided that the
 1010    * following conditions are met:
 1011    *
 1012    * 1. Redistributions of source code must retain copyright statements and
 1013    * notices. Redistributions must also contain a copy of this document.
 1014    *
 1015    * 2. Redistributions in binary form must reproduce the above copyright notice,
 1016    * this list of conditions and the following disclaimer in the documentation
 1017    * and/or other materials provided with the distribution.
 1018    *
 1019    * 3. The name "DOM4J" must not be used to endorse or promote products derived
 1020    * from this Software without prior written permission of MetaStuff, Ltd. For
 1021    * written permission, please contact dom4j-info@metastuff.com.
 1022    *
 1023    * 4. Products derived from this Software may not be called "DOM4J" nor may
 1024    * "DOM4J" appear in their names without prior written permission of MetaStuff,
 1025    * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
 1026    *
 1027    * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
 1028    *
 1029    * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
 1030    * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 1031    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 1032    * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
 1033    * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 1034    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 1035    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 1036    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 1037    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 1038    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 1039    * POSSIBILITY OF SUCH DAMAGE.
 1040    *
 1041    * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 1042    */
 
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.